UNIVERSIDAD DE CASTILLA-LA MANCHA ESCUELA SUPERIOR DE INFORMÁTICA GRADO EN INGENIERÍA INFORMÁTICA TRABAJO FIN DE GRADO KinBehR KINect for human BEHaviour Recognition Rubén Cantarero Navarro Julio, 2014 K IN B EH R KIN ECT FOR HUMAN BEH AVIOUR R ECOGNITION UNIVERSIDAD DE CASTILLA-LA MANCHA ESCUELA SUPERIOR DE INFORMÁTICA Tecnologías y Sistemas de Información TECNOLOGÍA ESPECÍFICA DE TECNOLOGÍAS DE LA INFORMACIÓN TRABAJO FIN DE GRADO KinBehR KINect for human BEHaviour Recognition Autor: Rubén Cantarero Navarro Director: Dra. María José Santofimia Romero Director: Dr. Juan Carlos López López Julio, 2014 Rubén Cantarero Navarro Ciudad Real – Spain E-mail: Rubé[email protected] Teléfono: 699 384 459 c 2014 Rubén Cantarero Navarro Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". Se permite la copia, distribución y/o modificación de este documento bajo los términos de la Licencia de Documentación Libre GNU, versión 1.3 o cualquier versión posterior publicada por la Free Software Foundation; sin secciones invariantes. Una copia de esta licencia esta incluida en el apéndice titulado «GNU Free Documentation License». Muchos de los nombres usados por las compañías para diferenciar sus productos y servicios son reclamados como marcas registradas. Allí donde estos nombres aparezcan en este documento, y cuando el autor haya sido informado de esas marcas registradas, los nombres estarán escritos en mayúsculas o como nombres propios. i TRIBUNAL: Presidente: Vocal: Secretario: FECHA DE DEFENSA: CALIFICACIÓN: PRESIDENTE Fdo.: VOCAL SECRETARIO Fdo.: Fdo.: iii Resumen Actualmente la sociedad está experimentado importantes cambios en los que, cada vez más, se confía en que la tecnología facilite el día a día de las personas. Es por eso que, de forma exponencial, están apareciendo continuamente sistemas y dispositivos enfocados a ayudar a las personas en su vida cotidiana. En este contexto, el reconocimiento de acciones humanas (Human Action Recognition) está comenzado a jugar un papel fundamental en importantes áreas cómo la vídeo-vigilancia, asistencia a personas mayores y discapacitados, la Interacción Persona-Ordenador, etc. El presente proyecto estudia cómo la utilización de cámaras de profundidad puede ayudar a mejorar las tasas de reconocimiento de acciones humanas en las que los movimientos corporales no han sido previamente preestablecidos. La metodología seguida está descompuesta en dos etapas. En la primera de ellas se ha estudiado cómo obtener e interpretar la información proporcionada por este tipo de cámaras y analizar qué puede aportar esta información al reconocimiento de acciones. En la segunda etapa se ha empleado un algoritmo de aprendizaje máquina, conocido como Bag of Words (B OW), que proporciona una estimación de la clasificación de acciones a partir de secuencias de vídeo mediante el análisis de las características de imágenes. Finalmente, mediante la utilización de diferentes conjunto de datos, se ha entrenado y evaluado el sistema propuesto de manera que se garantice la robustez del mismo ante la multimodalidad en la realización de acciones. Por esta razón también se ha llevado a cabo la elaboración de un dataset propio. Para concluir, los resultados obtenidos han sido comparados con otros estudios para verificar si este nuevo enfoque basado en el uso de cámara de profundidad supone una mejora en el reconocimiento de acciones humanas. V Abstract Society is currently experimenting major changes in which, everyday more, major responsibilities are being delegated to technology to simplify people daily lives. That is the reason why, exponentially, systems and devices are targeting their role as people helpers. In this context, recognising human actions (Human Action Recognition) is playing a key role in important areas such as video surveillance, assistance to elder and disabled people, the Human-Computer Interaction, etc. This project describes the implementation of a system for human action recognition, based on the novel use of in-depth cameras. This work therefore involves the evaluation of the use of in-depth cameras can help improving recognition rates obtained for human actions in which body movements have not been previously showed to the recognising system. The followed methodology is decomposed into two stages. During first stage we have studied how to obtain and interpret the information provided by these cameras as well as to identify the information brought into light by the recognised actions. During the second stage, a machine learning algorithm has been implemented, using B OW model. This model provides an estimate of the action classification from video sequences by analysing the image characteristics. Finally, the use of different datasets, one for training and a different one for testing, enriches the system with robustness and multimodality support. In order to enhance the system with these features, a new dataset has been designed and recorded, also made available for the scientific community. Finally, obtained results have been compared with state-of-the-art studies to verify whether the proposed approach improves existing approaches. VII Agradecimientos Estos últimos cuatro años han supuesto los mejores y peores años de mi vida, con momentos buenos y malos. Pero me gustaría quedarme con el recuerdo de todos aquellos buenos momentos que me han mejorado como profesional y, lo más importante, como persona. Sin embargo, es la hora de comenzar otra nueva etapa y, antes de ello, me gustaría aprovechar este breve espacio para agradecer a todas aquellas personas que de alguna u otra forma han hecho posible la finalización de estos estudios. En primer lugar, me gustaría dar las gracias a mis padres ya que sin ellos nada de esto hubiera sido posible. Ellos siempre me han dado su cariño incondicional y me han enseñado a valorar y a disfrutar de todas las cosas buenas que nos regala la vida. También me gustaría agradecerles que hayan creído en mí dándome la oportunidad de estudiar esta carrera, realizando el esfuerzo que sé que han tenido que hacer para que esto sea posible. También, agradecer al resto de mis familiares su preocupación constante y todos los consejos que en algún momento me han dado. A mis compañeros de la universidad Javi, David, Cristian, Cesár, Lalio, Jesús, ... y compañeros de piso, Dani y Juanma, por haber compartido conmigo todas estas alegrías, desvelos, inquietudes y entusiasmo en estos cuatro años. Por eso, quiero darles las gracias por haberse convertido en unos amigos maravillosos y que espero conservar durante mucho tiempo. También querría darles las gracias a mis directores de proyecto, María José y Juan Carlos, sin los cuáles este proyecto no hubiera llegado nunca a su fin. Querría agradecer en especial a María José todo el apoyo y confianza que ha depositado en mi estos últimos meses y a las oportunidades que me ha dado. Gracias a ella han aumentado mis ganas de aprender y enriquecer mis formación. Gracias a todos aquellos que me han ayudado a conseguir la beca de investigación/colaboración del Departamento de Tecnologías y Sistemas de la Información otorgada por el Ministerio de Educación durante la cual he desarrollado este proyecto, en especial a María José. También querría agradecerles que me permitieran disfrutarla junto a los compañeros del grupo ARCO, gracias a los cuales he aprendido mucho. No puedo olvidar dar las gracias a Luís Jimenez Linares por habernos prestado la Kinect con la que se ha realizado el proyecto ni a David Villa Alises por haber facilitado la plantilla LATEX de este documento. Por último, tampoco puedo olvidar dar las gracias a mis amigos de toda la vida, por su apoyo y preocupación hacia mí y por todos los buenos ratos que hemos compartido. Rubén Cantarero Navarro IX A mis padres, por su apoyo incondicional. xi Índice general Resumen V Abstract VII Agradecimientos IX Índice general XIII Índice de cuadros XIX Índice de figuras XXI Índice de listados XXV Listado de acrónimos XXVII 1. Introducción 1 1.1. Estructura del documento . . . . . . . . . . . . . . . . . . . . . . . . . . . 2. Objetivos 4 5 2.1. Objetivo general . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.1.1. Objetivos específicos . . . . . . . . . . . . . . . . . . . . . . . . . 5 3. Objectives 9 3.1. General objective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.1.1. Specific objectives . . . . . . . . . . . . . . . . . . . . . . . . . . 9 4. Antecedentes 13 4.1. Kinect para Xbox 360 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 4.1.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 4.1.2. La creación de Kinect . . . . . . . . . . . . . . . . . . . . . . . . 14 4.1.2.1. Precedentes . . . . . . . . . . . . . . . . . . . . . . . . XIII 15 4.1.2.2. Evolución . . . . . . . . . . . . . . . . . . . . . . . . . 17 4.1.2.3. Homebrew de Kinect . . . . . . . . . . . . . . . . . . . 21 4.1.3. Desarrollo de aplicaciones alternativas . . . . . . . . . . . . . . . . 24 4.1.3.1. Ocio . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.1.3.2. Medicina . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.1.3.3. Educación . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.1.3.4. Accesibilidad . . . . . . . . . . . . . . . . . . . . . . . 28 4.1.4. Características técnicas . . . . . . . . . . . . . . . . . . . . . . . . 30 4.1.4.1. Segunda generación de Kinect . . . . . . . . . . . . . . 32 4.1.5. Ventajas de Kinect frente a otros dispositivos . . . . . . . . . . . . 34 4.1.6. Funcionamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 4.1.6.1. Cámara RGB . . . . . . . . . . . . . . . . . . . . . . . 34 4.1.6.2. Cámara profundidad . . . . . . . . . . . . . . . . . . . . 35 4.1.6.3. Sistema de micrófonos . . . . . . . . . . . . . . . . . . 37 4.1.6.4. Motor de inclinación . . . . . . . . . . . . . . . . . . . . 37 4.1.7. ¿Por qué Kinect? . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 4.1.8. Librerías Kinect . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 4.1.8.1. SDK Windows . . . . . . . . . . . . . . . . . . . . . . . 4.1.8.1.1. Descripción del SDK . . . . . . . . . . . . . . . . . . . . . . . . . 40 Evolución del framework . . . . . . . . . . . . . . . . . . . . . . . . . 45 Ventajas y desventajas . . . . . . . . . . . . . . . . . . . . . . . . . 46 OpenNI . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.1.8.1.2. 4.1.8.1.3. 4.1.8.2. 4.1.8.2.1. Descripción del framework . . . . . . . . . . . . . . . . . . . . . . . . . 48 Evolución del framework . . . . . . . . . . . . . . . . . . . . . . . . . 53 Ventajas y desventajas . . . . . . . . . . . . . . . . . . . . . . . . . 55 OpenKinect . . . . . . . . . . . . . . . . . . . . . . . . 56 4.1.8.2.2. 4.1.8.2.3. 4.1.8.3. 40 4.1.8.3.1. Descripción del framework . . . . . . . . . . . . . . . . . . . . . . . . . 56 Ventajas y desventajas . . . . . . . . . . . . . . . . . . . . . . . . . 57 4.2. Visión por computador . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 4.1.8.3.2. xiv 4.2.1. Perspectiva de visión por computador . . . . . . . . . . . . . . . . 59 4.2.2. Algoritmos de reconocimiento de acciones basados en vídeo . . . . 60 5. Método de trabajo 65 5.1. Metodología de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 5.1.1. Acerca de Scrum . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 5.1.1.1. Fases de Scrum . . . . . . . . . . . . . . . . . . . . . . 67 5.1.1.2. Roles y responsabilidades . . . . . . . . . . . . . . . . . 68 5.1.1.3. Prácticas y conceptos relevantes . . . . . . . . . . . . . . 69 5.1.2. Descripción de la planificación . . . . . . . . . . . . . . . . . . . . 71 5.1.2.1. Fase 1: Pre-game . . . . . . . . . . . . . . . . . . . . . 72 5.1.2.2. Fase 2: Development . . . . . . . . . . . . . . . . . . . 73 5.1.2.2.1. Iteración 0 . . . . . . . . . . . . . . . . . . . . . . . . . 73 Iteración 1 . . . . . . . . . . . . . . . . . . . . . . . . . 74 Iteración 2 . . . . . . . . . . . . . . . . . . . . . . . . . 75 Iteración 3 . . . . . . . . . . . . . . . . . . . . . . . . . 75 Iteración 4 . . . . . . . . . . . . . . . . . . . . . . . . . 76 Iteración 5 . . . . . . . . . . . . . . . . . . . . . . . . . 77 Fase 3: Post-game . . . . . . . . . . . . . . . . . . . . . 78 5.2. Herramientas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 5.2.1. Aplicaciones de desarrollo . . . . . . . . . . . . . . . . . . . . . . 78 5.2.2. Lenguajes de programación . . . . . . . . . . . . . . . . . . . . . 80 5.2.3. Documentación y gráficos . . . . . . . . . . . . . . . . . . . . . . 80 5.2.4. Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 5.2.5. Sistemas operativos . . . . . . . . . . . . . . . . . . . . . . . . . . 81 5.1.2.2.2. 5.1.2.2.3. 5.1.2.2.4. 5.1.2.2.5. 5.1.2.2.6. 5.1.2.3. 6. Desarrollo del proyecto 83 6.1. Iteración 1: Primeros pasos con Kinect . . . . . . . . . . . . . . . . . . . . 84 6.1.1. Primer programa con Kinect . . . . . . . . . . . . . . . . . . . . . 85 6.1.1.1. La reflexión . . . . . . . . . . . . . . . . . . . . . . . . 86 6.1.1.2. La oclusión . . . . . . . . . . . . . . . . . . . . . . . . 87 6.1.1.3. Desalineamiento entre cámaras . . . . . . . . . . . . . . 88 xv 6.1.2. Apreciaciones a nivel de píxel . . . . . . . . . . . . . . . . . . . . 88 6.1.2.1. Píxeles RGB . . . . . . . . . . . . . . . . . . . . . . . . 89 6.1.2.2. Píxeles de profundidad . . . . . . . . . . . . . . . . . . 90 6.1.3. Conversión a distancias reales . . . . . . . . . . . . . . . . . . . . 92 6.1.4. Trabajando en tres dimensiones . . . . . . . . . . . . . . . . . . . 94 6.1.4.1. Nube de puntos . . . . . . . . . . . . . . . . . . . . . . 96 6.1.5. Afianzando los conceptos adquiridos . . . . . . . . . . . . . . . . . 101 6.1.5.1. Dibujando con Kinect . . . . . . . . . . . . . . . . . . . 101 6.1.5.2. Álbum de fotos . . . . . . . . . . . . . . . . . . . . . . 102 6.1.5.3. Batería virtual . . . . . . . . . . . . . . . . . . . . . . . 103 6.2. Iteración 2: Comprendiendo el funcionamiento de O PEN NI . . . . . . . . . 105 6.2.1. Aspectos básicos sobre la librería . . . . . . . . . . . . . . . . . . 106 6.2.1.1. openni::OpenNI . . . . . . . . . . . . . . . . . . . . . . 6.2.1.1.1. 107 Acceso al dispositivo . . . . . . . . . . . . . . . . . . . . . . . . . 107 Acceso a los flujos de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . 108 Acceso a los dispositivos a través de eventos . . . . . . . . . . . . . . . . . . . . . . . . . 108 Información de errores . . . . . . . . . . . . . . . . . . . . . . . . . 108 6.2.1.2. openni::Device . . . . . . . . . . . . . . . . . . . . . . . 109 6.2.1.3. openni::VideoStream . . . . . . . . . . . . . . . . . . . 110 6.2.1.4. openni::VideoFrameRef . . . . . . . . . . . . . . . . . . 110 6.2.2. GLUT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.2.3. Primera versión del módulo de captura de imágenes . . . . . . . . . 113 6.3. Iteración 3: Incorporación de NiTE . . . . . . . . . . . . . . . . . . . . . . 114 6.3.1. Toma de contacto con NiTE . . . . . . . . . . . . . . . . . . . . . 116 6.2.1.1.2. 6.2.1.1.3. 6.2.1.1.4. 6.3.1.1. Seguimiento de manos y detección de gestos . . . . . . . 116 6.3.1.2. Seguimiento del cuerpo . . . . . . . . . . . . . . . . . . 118 6.3.1.2.1. Funcionamiento . . . . . . . . . . . . . . . . . . . . . . . . . 118 Análisis e interpretación de la información proporcionada . . . . . . . . . . . . . . . . . . . . . . . . . 118 6.3.2. Evolución del módulo de captura de imágenes . . . . . . . . . . . . 120 6.3.1.2.2. 6.3.2.1. Segunda versión . . . . . . . . . . . . . . . . . . . . . . xvi 121 6.3.2.2. Tercera versión . . . . . . . . . . . . . . . . . . . . . . 126 6.3.2.3. Cuarta versión . . . . . . . . . . . . . . . . . . . . . . . 129 6.4. Iteración 4: Módulo de reconocimiento de acciones . . . . . . . . . . . . . 133 6.4.1. Modelo Bag of Words . . . . . . . . . . . . . . . . . . . . . . . . 134 6.4.2. Implementación de la solución propuesta . . . . . . . . . . . . . . 138 6.4.2.1. Fase 1: Configuración inicial . . . . . . . . . . . . . . . 143 6.4.2.2. Fase 2: Segmentación de vídeos . . . . . . . . . . . . . . 144 6.4.2.3. Procesamiento . . . . . . . . . . . . . . . . . . . . . . . 147 6.4.2.3.1. Fase 3: Extracción de características . . . . . . . . . . . . . . . . . . . . . . . . . 148 Fase 4: Clustering . . . . . . . . . . . . . . . . . . . . . . . . . 152 Fase 5: Proceso de reconocimiento . . . . . . . . . . . . . . . . . . . . . . . . . 154 6.5. Iteración 5: Interfaz gráfica . . . . . . . . . . . . . . . . . . . . . . . . . . 159 6.4.2.3.2. 6.4.2.3.3. 7. Resultados 167 7.1. Dataset de entrenamiento empleado . . . . . . . . . . . . . . . . . . . . . 167 7.2. Recogida de datos de prueba . . . . . . . . . . . . . . . . . . . . . . . . . 168 7.3. Análisis de los resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 8. Conclusiones y trabajo futuro 181 8.1. Objetivos alcanzados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 8.2. Trabajo futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 9. Conclusions and future work 187 9.1. Achieved objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 9.2. Future work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 A. Listados de los ejemplos con Processing 195 A.1. Ejemplo 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 A.2. Ejemplo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 A.3. Primer ejemplo de nube de puntos . . . . . . . . . . . . . . . . . . . . . . 197 A.4. Primer ejemplo de nube de puntos con movimiento . . . . . . . . . . . . . 198 A.5. Primer ejemplo de nube de puntos a color . . . . . . . . . . . . . . . . . . 199 A.6. Dibujando con Kinect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 A.7. Álbum de fotos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 A.8. Batería musical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 xvii B. Módulo de captura de imágenes 209 B.1. Diseño definitivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 B.1.1. Modelo de clases definitivo . . . . . . . . . . . . . . . . . . . . . . 209 B.1.2. Estructura de directorio definitivo . . . . . . . . . . . . . . . . . . 210 B.1.3. Modelo de flujo de la ejecución . . . . . . . . . . . . . . . . . . . 211 C. Formulario de consentimiento 213 D. Conclusión personal 219 Referencias 221 xviii Índice de cuadros 4.1. Especificación técnica Kinect. . . . . . . . . . . . . . . . . . . . . . . . . 31 4.2. Conjuntos de datos existentes, el número de categorías y el número de clips por categoría ordenados por año . . . . . . . . . . . . . . . . . . . . . . . 62 6.1. Resultados del tercer ejemplo con Processing. . . . . . . . . . . . . . . . . 95 6.2. Resultados obtenidos con ficheros PPM. . . . . . . . . . . . . . . . . . . . 130 6.3. Resultados obtenidos con ficheros JPEG. . . . . . . . . . . . . . . . . . . . 131 7.1. Información y número de acciones realizado por cada actor. . . . . . . . . . 170 7.2. Porcentaje de acierto de cada actor (sin guiar) en cada tipo de acción según el tipo de imagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 7.3. Porcentaje de acierto de cada actor (guiado) en cada tipo de acción según el tipo de imagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 7.4. Porcentaje de acierto de cada acción según el tipo de imagen (entorno guiado y sin guiar). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 7.5. Matriz de confusión de los vídeos RGB (entorno guiado y sin guiar). . . . . 176 7.6. Matriz de confusión de los vídeos de profundidad (entorno guiado y sin guiar).176 7.7. Matriz de confusión de los vídeos de los esqueletos (entorno guiado y sin guiar). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 7.8. Comparación de resultados con [MDRSN13]. . . . . . . . . . . . . . . . . 178 7.9. Comparación de resultados con [MDRSN13]. . . . . . . . . . . . . . . . . 178 XIX Índice de figuras 4.1. Kinect para Xbox 360 [web14n]. . . . . . . . . . . . . . . . . . . . . . . . 14 4.2. Wiimote para Wii [web14t]. . . . . . . . . . . . . . . . . . . . . . . . . . 15 4.3. PlayStation Move para PlayStation 3 [web14p]. . . . . . . . . . . . . . . . 15 4.4. Escena de “Minority Report” [web14s]. . . . . . . . . . . . . . . . . . . . 17 4.5. Disposición del dispositivo Wiimote [web14c]. . . . . . . . . . . . . . . . 18 4.6. Player blob [WA12]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.7. Player blob dividido en partes [WA12]. . . . . . . . . . . . . . . . . . . . 20 4.8. Johnny Lee mostrando las modificaciones al Wii Remote [web14f]. . . . . 22 4.9. Analizador de USB Beagle 480 [web14e]. . . . . . . . . . . . . . . . . . . 23 4.10. Kinect for Cooler Videoconferencing [web14q]. . . . . . . . . . . . . . . 24 4.11. Real-Time Princess Leia Holography Via Kinect Hack [web14x]. . . . . . 25 4.12. Ubi Interactive [wbU14]. . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.13. Fitnect [web14b]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.14. TedCas [wbT14a]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.15. VirtualRehab [wbV14]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.16. Juego River Corssing [web14i]. . . . . . . . . . . . . . . . . . . . . . . . 28 4.17. Kinect Math [web14l]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.18. Actividad “Baskets” integrada en la plataforma Jumpido [web14g]. . . . . 29 4.19. NAVI (Navigational Aids fot the Visually Impaired) [web14w]. . . . . . . 30 4.20. Kinect Sign Language Translator [web14r]. . . . . . . . . . . . . . . . . . 30 4.21. Distribución de los componentes en Kinect [web14k]. . . . . . . . . . . . 32 4.22. Distancia para el reconocimiento del esqueleto en Kinect [web14k]. . . . . 32 4.23. Segunda generación de Kinect [web14k]. . . . . . . . . . . . . . . . . . . 33 4.24. Componentes de un píxel. . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 4.25. Estructura del vector de bytes de la imagen. . . . . . . . . . . . . . . . . . 35 4.26. Fase de calibración del sistema de mapas de profundidad de la Kinect. . . . 36 4.27. Imagen de los puntos infrarrojos proyectados en una pared [Bor12]. . . . . 37 4.28. Fase de funcionamiento del sistema de mapas de profundidad de la Kinect. . 38 XXI 4.29. Disposición de los micrófonos en Kinect [web14k]. . . . . . . . . . . . . . 38 4.30. Arquitectura del SDK [web14j]. . . . . . . . . . . . . . . . . . . . . . . . 41 4.31. Interacción del hardware y software con una aplicación [web14j]. . . . . . 42 4.32. Articulaciones reconocidas por el SDK de Kinect [web14j]. . . . . . . . . . 43 4.33. Puntos del rostro humano reconocidos por el SDK de Microsoft [web14j]. . 43 4.34. Arquitectura de KinectInteraction [web14j]. . . . . . . . . . . . . . . . . . 44 4.35. Resultado obtenido a través de Kinect Fusion [web14j]. . . . . . . . . . . 44 4.36. Evolución del SDK de Kinect [WA12]. . . . . . . . . . . . . . . . . . . . . 46 4.37. AXUS Xtion [web14d]. . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 4.38. Arquitectura del framework O PEN NI 2 [web14u]. . . . . . . . . . . . . . . 49 4.39. Solución propuesta por Tomoto S. Washio [web14m]. . . . . . . . . . . . 51 4.40. 3D Hand [web14h]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 4.41. Resultado obtenido con KScan3D [web14a]. . . . . . . . . . . . . . . . . 53 4.42. Ejemplo de gesto reconocido con SigmaNIL [web14y]. . . . . . . . . . . . 54 4.43. Evolución de la arquitectura O PEN NI [web14u]. . . . . . . . . . . . . . . . 54 5.1. Fases de Scrum [web14z]. . . . . . . . . . . . . . . . . . . . . . . . . . . 68 5.2. Iteración de la metodología Scrum [web14z]. . . . . . . . . . . . . . . . . 70 6.1. Proyecto “MAY THE FORCE BE WITH YOU” de TeoPatk [wbT14b]. . . . 85 6.2. Captura del primer ejemplo con Processing. . . . . . . . . . . . . . . . . . 87 6.3. Scanner 3D con Kinect por Kyle McDonald [Bor12]. . . . . . . . . . . . . 87 6.4. Captura del segundo ejemplo con Processing. . . . . . . . . . . . . . . . . 88 6.5. Comparación entre los píxeles en una matriz bidimensional y una unidimensional [Bor12]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 6.6. Captura del tercer ejemplo con Processing. . . . . . . . . . . . . . . . . . . 95 6.7. Origen de coordenadas bidimensional en Processing [web14v]. . . . . . . 96 6.8. Origen de coordenadas tridimensional en Processing [web14v]. . . . . . . 97 6.9. Captura del primer ejemplo de “Nube de puntos”. . . . . . . . . . . . . . . 98 6.10. Captura del primer ejemplo de “Nube de puntos” donde sólo se representa uno de cada diez puntos capturados. . . . . . . . . . . . . . . . . . . . . . 98 6.11. Captura del primer ejemplo de “Nube de puntos” desde otro punto de vista. 99 6.12. Captura del primer ejemplo de “Nube de puntos” a color. . . . . . . . . . . 100 6.13. Captura de la aplicación “Dibujando con Kinect”. . . . . . . . . . . . . . . 102 6.14. Captura de la aplicación “Álbum de fotos”. . . . . . . . . . . . . . . . . . 103 6.15. Distribución de un cubo en Processing [Bor12]. . . . . . . . . . . . . . . . 105 6.16. Captura de la aplicación “Batería virtual”. . . . . . . . . . . . . . . . . . . 106 xxii 6.17. Diagrama de clases del módulo de captura de imágenes (versión 1). . . . . 114 6.18. Módulo de captura de imágenes en modo RGB. . . . . . . . . . . . . . . . 115 6.19. Módulo de captura de imágenes en modo profundidad. . . . . . . . . . . . 115 6.20. Funcionamiento del seguimiento de usuarios con NiTE [web14u]. . . . . . 119 6.21. Sistema de coordenadas de NiTE. . . . . . . . . . . . . . . . . . . . . . . 119 6.22. Articulaciones detectadas por NiTE [web14u]. . . . . . . . . . . . . . . . 121 6.23. Diagrama de clases del módulo de captura de imágenes (versión 2). . . . . 123 6.24. Resultado de la combinación de las técnicas de procesamiento. . . . . . . . 123 6.25. Resultado de la eliminación del fondo. . . . . . . . . . . . . . . . . . . . . 124 6.26. Dibujado del esqueleto sobre la imagen de profundidad. . . . . . . . . . . . 124 6.27. Dibujado del esqueleto eliminando el fondo. . . . . . . . . . . . . . . . . . 125 6.28. Imagen correspondiente al ejemplo 6.4. . . . . . . . . . . . . . . . . . . . 125 6.29. Estructura de directorios. . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 6.30. Modelo de flujo de la ejecución secuencial. . . . . . . . . . . . . . . . . . 128 6.31. Modelo de flujo de la ejecución concurrente. . . . . . . . . . . . . . . . . . 129 6.32. Gráfico comparativo del no de ficheros entre el formato PPM y JPEG. . . . . 131 6.33. Gráfico comparativo del tamaño total en megabytes entre el formato PPM y JPEG. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 6.34. Funcionalidad introducida en el módulo (versión 4). . . . . . . . . . . . . . 135 6.35. Imágenes originales. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 6.36. Extracción de características. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 6.37. Generación del diccionario (clustering). Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. . . . . . . . . . . . . . . . . . . . . . . . . 137 6.38. Cuantificación de características. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 6.39. Clasificador SVM. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 6.40. Diagrama de flujo de la solución propuesta. . . . . . . . . . . . . . . . . . 140 6.41. Diagrama de flujo de según las etapas. . . . . . . . . . . . . . . . . . . . . 142 6.42. Módulos del sistema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 6.43. Estructura de directorios de la solución propuesta. . . . . . . . . . . . . . . 145 xxiii 6.44. Diagrama de flujo de build_segmented_videos. . . . . . . . . . . . . . . . . 146 6.45. Fases de procesamiento. . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 6.46. Diagrama de la fase de extracción de características. . . . . . . . . . . . . . 150 6.47. Captura de stipdet de una imagen de profundidad capturada con Kinect. . . 151 6.48. Diagrama de new_sequence_cluster_choice_k . . . . . . . . . . . . . . . . 154 6.49. Diagrama de la fase de proceso de reconocimiento. . . . . . . . . . . . . . 163 6.50. Funcionalidad de Grabación. . . . . . . . . . . . . . . . . . . . . . . . . . 164 6.51. Funcionalidad de etiquetado. . . . . . . . . . . . . . . . . . . . . . . . . . 164 6.52. Sección de clasificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 6.53. Sección de Resultados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 7.1. Ejemplo de IXMAS. [wbI14] . . . . . . . . . . . . . . . . . . . . . . . . . 169 7.2. Escenario de grabación empleado. . . . . . . . . . . . . . . . . . . . . . . 170 7.3. Porcentaje de acierto de cada acción según el tipo de imagen (entorno guiado y sin guiar). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 7.4. Problema encontrado en vídeos de profundidad. . . . . . . . . . . . . . . . 179 7.5. Problema encontrado en vídeos de esqueletos. . . . . . . . . . . . . . . . . 179 B.1. Diagrama de clases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 B.2. Estructura de directorios. . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 B.3. Modelo de flujo de la ejecución concurrente. . . . . . . . . . . . . . . . . . 211 xxiv Índice de listados 6.1. «Ejemplo 1» versión 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 6.2. «Dibujando con Kinect» . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.3. Detección de poses con NiTE . . . . . . . . . . . . . . . . . . . . . . . . . 117 6.4. Ejemplo del formato PPM. . . . . . . . . . . . . . . . . . . . . . . . . . . 126 6.5. Estructura fichero XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 6.6. Estructura fichero ACTOR_frame_segmented.txt. . . . . . . . . . . . . . . 145 6.7. Estructura fichero de datos del clasificador SVM. . . . . . . . . . . . . . . 156 6.8. Ejemplo de la estructura fichero de datos del clasificador SVM. . . . . . . . 157 A.1. «Ejemplo 1» [Bor12] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 A.2. «Ejemplo 2» [Bor12] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 A.3. «Primer ejemplo Nube de puntos» [Bor12] . . . . . . . . . . . . . . . . . 197 A.4. «Primer ejemplo Nube de puntos con movimiento» [Bor12] . . . . . . . . 198 A.5. «Primer ejemplo Nube de puntos a color» [Bor12] . . . . . . . . . . . . . 199 A.6. «Dibujando con Kinect» [Bor12] . . . . . . . . . . . . . . . . . . . . . . 200 A.7. «Álbum de fotos» [Bor12] . . . . . . . . . . . . . . . . . . . . . . . . . . 202 A.8. Clase Hotpoint de la aplicación «Batería musical» [Bor12] . . . . . . . . . 204 A.9. Clase principal de la aplicación «Batería musical» [Bor12] . . . . . . . . . 205 XXV Listado de acrónimos KinBehR KINect for human BEHaviour Recognition BSD Berkeley Software Distribution MSR Microsoft Research SDK Software Development Kit NAVI Navigational Aids fot the Visually Impaired TOF Time-Of-Flight TFG Trabajo Fin de Grado HMM Hidden Markov Models GMM Modelos de Mezclas Gaussianas IEEE Institute of Electrical and Electronics Engineers AVSS Advanced Video and Signal Based Surveillance MHI Motion History Images SOM Kohonen Self Organizing feature Map SIR Sampling Importance Resampling ML Maximum Likelihood SVM Support Vector Machines BoW Bag of Words CLG Combined Local-Global LPP Locality Preserving Projections TVTL Temporal-Vector Trajectory Learning LTM Locations’ Temporal motion of Mahalanobis distance DTM Difference’ Temporal motion of Mahalanobis distance TTM Trajectory Temporal motion of Mahalanobis distance IN Internación Natural API Application Programming Interface LGPL Lesser General Public License XXVII OpenNI Open Natural Interaction 3D Tres dimensiones IDE Integrated Development Environment CPU Central Processing Unit FORTH Foundation for Research and Technology-Hellas DMO DirectX Media Objec USB Universal Serial Bus NUI Natural User Interface RAM Random Access Memory HTML HyperText Markup Language GPL General Public License JNA Java Native Access JNI Java Native Interface GLUT OpenGL Utility Toolkit ANSI American National Standards Institute FORTRAN Formula Translating System PPM Portable PixMap format PGM Portable Gray Map ASCII American Standard Code for Information Interchange POSIX Portable Operating System Interface JPEG Joint Photographic Experts Group XML eXtensible Markup Language IXMAS INRIA Xmas Motion Acquisition Sequences PERL Practical Extraction and Report Language GUI Graphical User Interface INRIA Institut National de Recherche en Informatique et en Automatique STIP Space-time Interest Points HOF Histograms of Optical Flow HOG Histograms of Oriented Gradients LUT Look Up Table KDE K Desktop Environment GCC GNU Compiler Collection GNU GNU is Not Unix xxviii Capítulo 1 Introducción La búsqueda de espacios cada vez más inteligentes en los que el propio entorno dé soporte a personas de la tercera edad (Ambient Assited Living), personas en su vida cotidiana (Ambient Intelligence) o ciudadanos (Smart Cities) plantea, como primer reto, el desarrollo de tecnologías o sistemas capaces de identificar las acciones que estas personas están llevando a cabo en ese entorno. El reconocimiento de acciones humanas es, sin embargo, uno de los principales retos de la comunidad científica y muy especialmente en el área de la visión por computador. En este sentido, la aproximación más común consiste en extraer imágenes características de vídeos y caracterizar y etiquetar estas imágenes con la correspondiente acción que se está realizando en ellas. Para ello se suele recurrir a un algoritmo de clasificación previamente entrenado con las acciones a reconocer. Sin embargo, el enfoque basado en vídeo no es el único. Así, en el estado del arte podemos identificar diferentes propuestas que van desde las más intrusivas, como las basadas en sensores desplegados a lo largo del cuerpo [XZSS12] hasta otras como las basadas en el análisis de los valores obtenidos por los sensores de los teléfonos móviles [AGO+ 12]. Pero, independientemente del enfoque aplicado, la realidad es que el reconocimiento de acciones humanas es una tarea tremendamente compleja. Esa complejidad, en el caso particular del reconocimiento de acciones humanas basadas en el análisis de vídeo, se deriva de los diferentes retos que esta tarea debe abordar. En primer lugar hay que hacer frente a la importante variabilidad en el rendimiento obtenido en el reconocimiento de distintas acciones. Un ejemplo de ello podría ser como en los movimientos que implica el caminar, las zancadas de cada persona pueden diferir en gran medida. Esto se debe a que los movimientos corporales implicados en una determinada acción no son únicos y no están perfectamente delimitados, variando de unas personas a otras e incluso dentro de la misma persona. Esto supone un gran desafío ya que una buena aproximación para el reconocimiento de acciones debería ser capaz de generalizar sobre las variaciones dentro de una clase y distinguir entre las acciones de diferentes clases. De este modo, cuando exista un gran número de las clases de acción, esto será aún más complicado ya que el solapamiento entre las clases será mayor. 1 Otro reto que debe ser tenido en cuenta es la naturaleza cambiante del entorno donde se producen las acciones. Esto implica serias dificultades en diferentes aspectos que deben ser considerados. Ejemplos de ellos podrían ser cómo partes de una persona pueden ser ocluidas en las grabaciones o la influencia que pueden tener las condiciones de luminosidad en la apariencia de una persona. No obstante, esta tarea también se encuentra con el reto que suponen las variaciones temporales. Por consiguiente, la velocidad a la que se registra la acción tiene un efecto importante en la extensión temporal de una acción, especialmente cuando se utilizan funciones de movimiento. Un algoritmo de reconocimiento robusto de acciones humanas debería ser invariante a diferentes ritmos de ejecución. Recientemente, algunos investigadores han utilizado cámaras RGBD, como Microsoft Kinect, para intentar abordar los retos mencionados arriba. Estas cámaras de profundidad añaden una dimensión extra que las cámaras 2D normales no proporcionan. De este modo, la información sensorial proporcionada por este tipo de cámaras se han empleado para generar modelos del esqueleto humano en tiempo real que permiten considerar las diferentes posiciones del cuerpo. Estos modelos del esqueleto proporciona información significativa que los investigadores han usado para modelar las actividades humanas que han sido usadas en el entrenamiento del algoritmo de clasificación y que posteriormente serán empleadas para el reconocimiento de actividades desconocidas. Este trabajo está motivado por la necesidad de abordar el problema de cómo las posturas corporales inciden en la tarea de reconocimiento de acciones humanas basadas en el análisis de vídeo. De este modo se parte de la hipótesis de trabajo de que el uso de cámaras de profundidad puede ayudar a mejorar las tasas de reconocimiento de acciones humanas en las que los movimientos corporales no han sido predefinidos, sino que dependerán de la persona que los realice. Este trabajo está inspirado en el trabajo de [NLT+ 11] en el que se presenta un análisis entre diferentes técnicas para abordar la tarea del reconocimiento de acciones, demostrando que la técnica que ofrece el mayor equilibrio tiempo/rendimiento es la técnica de Bag of Words (B OW) con una precisión del 63.9 %. El modelo B OW surgió como una aproximación motivada en métodos de categorización de texto [Joa98b] [TK02] [LSST+ 02] [CSTL02]. No obstante, se han publicado estudios [ZRZ02] en los que la idea de adaptar la categorización de texto a la categorización de vídeo puede resultar verdaderamente interesante. Es por ello por lo que en los últimos años se ha demostrado que B OW [KB10] [LAS08] [LP07] es uno de los métodos más precisos para el reconocimiento de acciones, capaz de actuar en una gran variedad de escenarios con un coste computacional realmente bajo. Al contrario de lo que sucede con otras técnicas de clasificación de acciones humanas [WBR07] [YKS08], B OW no requiere ningún algoritmo adicional de segmentación, lo que simplifica la tarea de visión por computador haciendo, por lo tanto, posible trabajar directamente con datos de vídeo. Utilizando la metodología propuesta en [MDRSN13], en la que también se abordaba el 2 problema del reconocimiento de acciones humanas realizadas de manera multimodal, este proyecto trabajará con un sistema entrenado con un conjunto de datos (dataset) distinto del utilizado en la clasificación, comprobando de esta manera la robustez del sistema ante la multimodalidad en la realización de acciones. Aunque el citado trabajo presentaba un sistema combinado de BoW y un algoritmo de razonamiento, en él se proporcionan resultados del rendimiento obtenido por el algoritmo BoW, entrenado con un conjunto de datos diferente al utilizado en la clasificación. Este trabajo utilizará esos datos para compararlos con los obtenidos en un experimento similar, utilizando cámaras de profundidad en lugar de cámaras 2D. Dado que no hay vídeos estándar adecuados para la descripción de la complejidad de las acciones de la vida real con un conjunto de actividades complejas que sean lo suficientemente representativas, se procederá a la creación de un nuevo dataset, “KinbehrDataset”. “KinbehrDataset” estará compuesto por acciones realizadas por diversos individuos en un entorno no controlado. Para la creación de dicho dataset se empleará un método científico de recogida de datos que asegure la validez de las muestras recogidas. Además, es importante mencionar que será puesto a disposición del resto de la comunidad científica con el fin de que lo resultados obtenidos en el presente estudio puedan ser comparados con futuros proyectos. De este modo, se emplearán dataset distintos para el entrenamiento y evaluación del sistema propuesto. Esto permitirá mostrar la generalidad de la solución, sus capacidades en las diversas aplicaciones de la vida real y su rendimiento en situaciones complejas. Por tratarse éste de un proyecto con alto contenido de investigación, la elaboración de este trabajo seguirá la siguiente metodología. En primer lugar se realizará un análisis de las diferentes cámaras de profundidad que se encuentran disponibles en el mercado, teniendo en cuenta diferentes aspectos como el precio, disponibilidad, prestaciones, soporte, etc. Es importante destacar que debido a limitaciones presupuestarias y al bajo precio que ofrece, este análisis estará limitado a los diferentes modelos del dispositivo Kinect de Microsoft. Seguidamente se trataran los conceptos más relevantes a tener en cuenta en el tratamiento, procesamiento e interpretación de las diferentes imágenes proporcionadas por el dispositivo elegido. El siguiente paso a abordar será el desarrollo de un módulo que permita capturar los diferentes flujos de información proporcionados por los sensores del dispositivo. Para ello, será necesario seguir una serie de pasos bien definidos, entre los cuales destacan la realización de un estudio de los frameworks disponibles para el dispositivo elegido, analizar las peculiaridades que presenta, etc. Seguidamente se procederá a adaptar la solución propuesta al modelo B OW. Para ello, se dividirá este proceso en dos etapas bien diferenciadas. La primera consistirá en el entrenamiento del sistema con un dataset público que se adapte a los objetivos perseguidos. De este modo, se realizará un estudio sobre los diferentes dataset disponibles. Posteriormente, se llevará a cabo la segunda etapa que consistirá en la evaluación del sistema mediante el dataset 3 “KinbehrDataset”, constituido a partir de grabaciones con diferentes flujos de información (imagen a color, profundidad, etc.) de cada individuo. Finalmente, se procederá a la validación e interpretación de los resultados obtenidos pudiendo comprobar si la hipótesis de trabajo con la que se comenzó se cumple. 1.1 Estructura del documento El presente documento se estructura en siete capítulos bien diferenciados. El primero de ellos, donde el lector se encuentra en este momento, se ha mostrado una visión general sobre la hipótesis de trabajo desde la que se parte y así como la forma en la que se pretende abordar. En el capítulo de “Objetivos” se presenta el objetivo general y los distintos objetivos específicos que se persiguen con la realización del TFG. En el capítulo de “Antecedentes” se pretende ofrecer al lector una visión detallada sobre el dispositivo Kinect y el estado del arte de la visión por computador. El siguiente capítulo, “Método de trabajo”, versa sobre la metodología de desarrollo empleada, la planificación del proyecto y las diferentes herramientas empleadas para su realización. Seguidamente, en el capítulo “Desarrollo del proyecto”, que constituye el núcleo del documento, se expone el trabajo realizado en las diferentes iteraciones en las que se ha dividido el proyecto. En los dos últimos capítulos, “Resultados” y “Conclusiones y trabajo futuro”, finalmente se exponen los resultados obtenidos en base a la hipótesis de trabajo de la que se partió y se analiza en que grado han sido logrados los objetivos, respectivamente. 4 Capítulo 2 Objetivos E este capítulo se detallan los objetivos del proyecto, tanto generales como específicos. De esta manera, se pretende dar a conocer al lector el alcance al que se pretende llegar con la realización del mismo. N 2.1 Objetivo general En este proyecto se ha desarrollado un algoritmo de “aprendizaje máquina” (machine learning) que combina el análisis de imágenes de intensidad y profundidad con una base de conocimiento donde se contenga información de alto nivel sobre acciones humanas. El sistema de reconocimiento estará basado en un clasificador de máquina de vectores de soporte o Support Vector Machines (SVM) para lo cual será necesario disponer de una batería de casos de entrenamiento y otra de testeo. Se realizará una revisión del estado del arte para identificar la existencia de dataset públicos que puedan servir para entrenar al sistema. Sin embargo, el sistema a desarrollar no se basará en el reconocimiento de acciones aisladas, sino que buscará interpretar y entender la actividad de más alto nivel que está siendo desarrollada por la persona para mitigar así los errores de reconocimiento de acciones que carecen de sentido en el contexto actual y que son reportadas por el sistema. Para ello, será necesario generar un dataset en el que se pueda asegurar que las personas están realizando las acciones con las que se ha entrenado el sistema pero de una manera racional, es decir, motivada por un objetivo concreto. Por lo tanto, también será objetivo de este proyecto la generación de dicho dataset a partir de la grabación y etiquetado de escenarios concretos, donde se realice al menos un número relevante de las acciones con las que el sistema haya sido entrenado. Dichas acciones dependerán de las acciones disponibles en los datasets públicos ya que, utilizando un dataset para entrenar el sistema distinto del utilizado para su evaluación, se asegurará la validez del sistema propuesto. 2.1.1 Objetivos específicos En este apartado se mostrarán los distintos objetivos específicos que han sido marcados para el desarrollo de K IN B EH R. Evaluación de mercado: Realizar una análisis exhaustivo sobre los diversos dispositi5 vos Kinect disponibles (Kinect for Xbox 360, Kinect for Windows y Kinect de segunda generación) y estudiar qué dispositivo es el que mejor se adapta para el desarrollo de la actividad del proyecto. Así mismo también se pretende proporcionar una visión general sobre la evolución que han experimentado este tipo de dispositivos a lo largo de la historia, haciendo especial inca pie en los cambios más importantes de los últimos años. Análisis de librerías disponibles: Realizar un estudio sobre las diferentes plataformas y/o librerías disponibles que actualmente proporcionan soporte a Kinect, identificando y evaluando de esta manera qué funcionalidades ofrecen, lenguajes de programación soportados por cada uno/a, limitaciones, ventajas y desventajas, compatibilidad, etc. También se pretende ofrecer una visón general sobre la evolución que han experimentado en los últimos años prestando especial interés en las nuevas posibilidades que frece cada una. Identificación y análisis de los datos recogidos por el dispositivo: Identificar los flujos de información proporcionados por los diferentes sensores de Kinect (profundidad, sonido, acelerómetro, etc.) y analizar las diversas formas de interpretarlos, manipularlos y procesarlos para su posterior explotación. De esta forma será necesario familiarizarse y comprender los conceptos más importantes relacionados con las imágenes (especialmente con las imágenes de profundidad). Posteriormente, esto proporcionará la base sobre la que se desarrollará un módulo que permita la captura de imágenes mediante el dispositivo Kinect, intentando en todo momento exprimir al máximo las posibilidades que ofrece y que son de especial interés para el presente proyecto. Identificación y análisis del conjunto de acciones a reconocer: Una vez identificados los datos recogidos por el dispositivo es necesario identificar las diferentes acciones que se van a reconocer y monitorizarlos para, posteriormente, llevar a cabo un análisis de los patrones que caracterizan a cada uno. Esto proporcionará la base para el reconocimiento de dichos patrones por el sistema a desarrollar. Adaptación del modelo Bag of Words: Realizar un pequeño estudio para proporcionar una visión general acerca del estado del arte sobre las soluciones existentes. También será necesario analizar y comprender en profundidad los conceptos más importantes acerca del funcionamiento del modelo Bag of Words (B OW), así como la forma en la que se puede adaptar la solución proporcionada al presente proyecto. Por lo tanto, la consecución de este subobjetivo será clave para la implementación de un módulo que, junto a un clasificador, permita la identificación de acciones. Desarrollo de un clasificador (SVM): Para ello será necesario investigar, analizar y diseñar las diferentes técnicas de clasificación para el reconocimiento de patrones de gestos corporales que se pretenden monitorizar. Una vez realizado este primer paso, se procederá a la implementación del/de los clasificador/es, el entrenamiento y evaluación 6 del mismo. Organización del conjunto de sujetos del experimento: A través de un método científico de recogida de datos se pretende confeccionar un conjunto de datos (ejemplos de entrenamiento o muestras) de diferentes individuos. Esto servirá como base para el etiquetado de las clases y el entrenamiento del clasificador SVM, teniendo como objetivo final la construcción de un modelo que permita predecir la clase de una nueva muestra. Asociado a esta tarea, también será necesario la interpretación de la legislación vigente para la elaboración de acuerdos con los individuos de manera que todo el procedimiento sea conforme a la legislación vigente respecto de la protección de datos de carácter personal. Desarrollo de una interfaz gráfica: Mediante el desarrollo de una interfaz gráfica se pretende integrar los diferentes módulos desarrollados a lo largo del proyecto, así como facilitar a los futuros usuarios del sistema su utilización. 7 Capítulo 3 Objectives This chapter describes the project objectives, both from a general and more specific perspective, therefore stating the project scope and the expected results. 3.1 General objective In this project we have developed a machine learning system that combines intensity and in-depth image analysis with a knowledge base containing high level information about human actions. The recognition system will be based on a support vector machine classifier, so-called Support Vector Machines (SVM). This classifier will be trained with a specific dataset specifically recorded for human action recognition. A review of the state of the art will be performed to identify the existence of public dataset that can be used for the system training. However, the system to be developed will not be based on the recognition of isolated actions. On the contrary, it will seek the interpretation and understanding of higher abstraction level actions. Performing in-context human action recognition enables the recognition system to mitigate the impact of recognition errors, reported by the system but making no sense from the point of view of the context in which the actions are taking place. In order to take the context into account, it will be necessary to generate a dataset in which it can be assumed that people are performing the actions with which the system has been trained but in a rational way. The main implication of assuming the rationality of the actions being performed is that they are motivated by a concrete objective. In this sense, it is also among the project objectives to generate a dataset where actions are performed in a rational manner, rather than being based on commands. This requires recording and labelling specific scenarios where actors perform a significant number of actions with which the system has been trained. These actions will depend on the ones being provided by the available public datasets. However, it is important to highlight that the dataset used for training is different from the one being used for testing and validating the implemented system. 3.1.1 Specific objectives In this section the specific objectives stated for the development of K IN B EH R are displayed. Market analysis: to undertake a market analysis of the different Kinect devices avai9 lable in the market (Kinect for Xbox 360, Kinect and Kinect for Windows second generation) and, among existing ones, to consider which one better fits this project requirements. This market analysis is also intended to provide an overview of the evolution that have experienced such devices throughout history, making special emphasis in recent years changes. Analysis of available libraries: to conduct a study of the different platforms and/or available libraries currently providing support for Kinect, by identifying and evaluating offered features, programming languages, limitations, advantages and disadvantages, compatibility, etc. It also aims to provide an overview of the evolution experienced in recent years with special attention to the new offered functionality. Identification and analysis of the device collected data: to identify the information flows provided by Kinect sensors (in-depth, sound, accelerometer, etc.) and to analyze the different ways of interpreting, manipulating and processing these values for later manipulations. This objective involve getting familiar and understanding the most important concepts related to images (especially in-depth images). Later, this will provide the basis on which a module that allows image capture using the Kinect device, trying to squeeze the most of of the possibilities offered and that are of special relevance to this project will be developed. Identification and analysis of the set of actions to be considered: once collected data has been identified by the device it is necessary to state the different actions that will be considered in the proposed system by performing an action characterisation. This will provide the basis for the recognition of these patterns by the system to be developed. Adapting the Bag of Words Model: to carry out a thorough analysis of the state of the art solutions for human action recognition. It will also be necessary to analyze and understand the most important concepts about the B OW model basis, and how this model has to be adapted in order to be implemented in the proposed system. Therefore, achieving this sub-goal will be key to the implementation of a module, along with a classifier, enabling action identification. An (SVM) classifier development: before selecting a specific approach a previous research and analysis have to be carried out in order to identify the different classification techniques for pattern recognition of body gestures. This goal also involve the implementation and training of the classifier as well as its performance validation. Selecting and organising the set of experimental subjects: since the system validation is going to be performed using a different dataset than the one used for training purposes, this objective requires the implementation of a scientific method for data collection. This objective will therefore result in a new dataset used for testing or validating purposes. This will serve as the basis for labelling classes and training the 10 classifier SVM, with the ultimate goal of building a model to predict the class of a new sample. Closely related to this task is the interpretation of existing legislation for consent agreements so that the whole procedure compliant with current legislation regarding personal data protection. Developing a graphical user interface: the development of a graphical user interface is intended to integrate the different modules developed during this project as well as to simplify the use of the system potential users. 11 Capítulo 4 Antecedentes E presente capítulo tiene como objetivo proporcionar una visión general sobre los conceptos más importantes tratados en este proyecto. Para ello, se ha comenzado hablando sobre Kinect, revisando cuestiones interesantes como su historia y evolución, aplicaciones de Kinect en el mundo real, las prestaciones técnicas que ofrece, las diferentes librerías que hay disponibles para desarrollar con Kinect; las diferentes versiones del dispositivo así como los conceptos más básicos sobre su funcionamiento y que más adelante serán necesarios para entender el resto del documento. L En la segunda parte del capítulo se ofrece una visión general sobre el estado actual de la cuestión de visión por computador, centrándose en los trabajos realizados en los últimos años, así como los algoritmos de reconocimiento de acciones más conocidos hasta el momento. 4.1 Kinect para Xbox 360 En la siguiente sección se proporcionarán algunos antecedentes acerca de dónde proviene Kinect Xbox 360 y cual ha sido su evolución a lo largo de los años, así como la forma en la que funciona el dispositivo y las ventajas y desventajas que ofrece para el diseño y desarrollo de sistemas de visión por computador. 4.1.1 Introducción Kinect para Xbox 360 (ver Figura 4.1), a partir de ahora Kinect, es «un controlador de juego libre y entretenimiento» creado por Alex Kipman y desarrollado por Microsoft para la videoconsola Xbox 360 y desde junio del 2011 para PC mediante Windows. Basado en una cámara web y pensado como un periférico para ambas plataformas, permite a los usuarios, por ejemplo, controlar e interactuar con la consola Xbox 360 sin necesidad de tener ningún contacto físico con un controlador de videojuegos tradicional, como pueden ser los mandos o joysticks. Todo ello se realiza a través de una interfaz de usuario natural usando gestos y comandos de voz. En un principio, el proyecto de Kinect estaba orientado a ampliar la audiencia de la Xbox 360 más allá de la base de un jugador típico. A continuación, se muestra uno de los comen13 Figura 4.1: Kinect para Xbox 360 [web14n]. tarios más destacados que fue realizado por Los Angeles Times el 1 de Junio de 2009 tras asistir al Electronic Entertainment Expo en Los Ángeles: “Microsoft wants people to start using their full bodies to play video games. The Redmond software giant showed off a sensor-based technology that recognizes faces, voices and body joints to affect the movements on screen. In a demo game called Ricochet, players can use their arms, legs, torso and head to block an onslaught of virtual projectiles. Another game called Paint Party lets users splash virtual paint onto an on-screen canvas. Players call out different colors to change the palette. The effort aims to attract a broader audience to Microsoft’s console. Most of the 30 million Xbox 360s sold since November 2005 has been snapped up by avid young males drawn to complex shooter or adventure games such as Halo and Gears of War”. No obstante, Kinect también fue lanzado al mercado con el objetivo de proporcionar una interfaz de usuario que de forma natural fuera capaz de reconocer gestos, comandos de voz, etc. para hacer frente a los sistemas de la competencia, como Wiimote con Wii MotionPlus (ver Figura 4.2) y PlayStation Move (ver Figura 4.3), que también permitían controlar el movimiento de las consolas Wii y PlayStation 3, respectivamente. 4.1.2 La creación de Kinect Los antecedentes de Kinect comienzan mucho antes de que el propio dispositivo fuera concebido. Kinect surge como el resultado de varias décadas de análisis e investigación sobre interfaces de usuario basadas en gestos y voz. Quizá el gran éxito que cosechó la película Minority Report en el año 2002, con su forma de interpretar una interfaz de usuario natural sin necesidad de emplear controladores, fue unos de los hechos que provocó la gran avalancha de avances que se sucederían en los años venideros. Posteriormente, como se comentó 14 Figura 4.2: Wiimote para Wii [web14t]. Figura 4.3: PlayStation Move para PlayStation 3 [web14p]. en el párrafo anterior, la rivalidad entre las consolas de videojuegos para diseñar controladores naturales de calidad fue lo que terminó provocando la llegada de este dispositivo a los salones de todo el mundo. No obstante, fue la filosofía de intentar desbloquear todo aquello que es ocultado lo que definitivamente permitió abrir las puertas a los desarrolladores. 4.1.2.1. Precedentes Una de las personas más influyentes en la interacción persona-computador, Bill Buxton, ha comentado en numerosas ocasiones durante los últimos años sobre lo que el llama “The Long Nose of Innovation”, en referencia al término acuñado por el director de la revista Wired, Chris Anderson: “The Long Nose”. Este término hace referencia a las décadas de trabajo necesario para desarrollar una tecnología “revolucionaria” que surge, de forma aparente, de 15 la nada. Uno de los ejemplos más destacables es la invención del ratón, que supuso una importante revolución en la interfaz gráfica de usuario tras largos años de perfeccionamiento. El primer ratón fue construido por Douglas Engelbart y Bill English en el Stanford Research Institute en 1963. No obstante, no fue hasta 1995 con el lanzamiento de la versión del sistema operativo Windows 95 cuando el ratón se convirtió en un periférico indispensable para todo el mundo. The Long Nose describe los 30 años necesarios para que dispositivos como el ratón pasen de ser una invención a ser omnipresentes en la industria Algo muy similar a este estudio de 30 años descrito por The Long Nose puede ser aplicado al proceso de invención y desarrollo de Kinect. Chris Schmandt en el Architectural Machine Group del MIT comenzó a finales de los años 70 un proyecto de investigación llamado “Put-That-Here”, basado en una idea de Richard Bolt de reconocimiento combinado de voz y gesto como vectores de entrada de un interfaz gráfica. Este proyecto estaba acoplado en una habitación con una gran pantalla de proyección, donde el usuario debía sentarse en una silla de vinilo a una distancia aproximada de ocho metros frente a la pantalla. Además disponía de un pequeño dispositivo magnético que se encontraba oculto en una muñeca que realizaba las labores de receptor del movimiento espacial que se produjera, además de un micrófono instalado en la cabeza. De este modo, gracias a estos “dispositivos” y mediante procesos de lógica elementales de reconocimiento de pronombres como “aquí” o “eso”, el usuario era capaz de crear y mover formas de manera muy básica en la pantalla. Versiones posteriores este proyecto permitían a los usuarios guiar a barcos a través del mar Caribe o colocar edificios coloniales en el mapa de Boston. En el año 1993, David Koonz, Thorrison Kristinn, y Carlton Sparrell llevaron a cabo en el MIT Media Labs otro proyecto de investigación dirigido por Bolt: “The Iconic System”. En dicho proyecto se continuo la idea del proyecto Put-That-Here realizado anteriormente con el objetivo de que en dicha ocasión fuera posible trabajar con gestos, palabras y el movimiento del ojo. Otra novedad fue que en esta ocasión los resultados eran proyectados en un espacio de tres dimensiones generada mediante un ordenador. Además, en lugar de los cubos magnéticos utilizados con Put-That-Here, The Iconic System utilizaba un sistema de guantes especiales para facilitar el seguimiento de los gestos de usuario. Marcos Lucente desarrolló a finales de los 90 una interfaz de usuario avanzada para IBM Research: “DreamSpace”. No obstante, esta interfaz llegó a estar operativa en una gran variedad de plataformas incluyendo Windows NT. Una de las principales características que la diferenciaban de sus predecesores era que DreamSpace no empleaba tubos ni guantes para llevar a cabo el reconocimiento de gestos, empleando por lo tanto un sistema de visión. Esta variante fue concebida para trabajar más allá de entornos especializados, suponiendo por lo tanto una alternativa viable al ratón y al teclado. 16 En 1999, John Underkoffler el cual era por aquel entonces miembro del MIT Media Labs participó en un nuevo proyecto de Stephen Spielberg: “Minority Report“ (ver Figura 4.4). De este modo, Jhon junto con Alex McDowell, Diseñador de Producción, diseñaron la interfaz de usuario que Tom Cruise utilizaría en la película. Algunos de los conceptos de diseño de la interfaz de usuario de Minority Report finalmente terminaron en otro proyecto de Underkoffler llamado ”G-Speak“. Figura 4.4: Escena de “Minority Report” [web14s]. 4.1.2.2. Evolución Nintendo fue la compañía que dio el primer paso hacía un nuevo paradigma de entender los videojuegos y de cómo el usuario puede interaccionar con la consola. En el Tokyo Game Show de 2005, la presentación de su nueva consola Wii fue acompañada por un nuevo dispositivo de juego llamado Wiimote (ver Figura 4.5). De manera similar en la que trabajaba el proyecto Put-That-There (véase § 4.1.2.1) con sus cubos magnéticos, el controlador de Wii era capaz de detectar el movimiento que se produjera a lo largo de los tres ejes, contando además con un sensor óptico que recogía el lugar donde apuntara el dispositivo, todo ello de forma inalámbrica. Peter Moore, el entonces jefe de la división Xbox de Microsoft, tras comprobar el éxito que cosechó Nintendo con Wiimote decidió comenzar a desarrollar una alternativa que fuera capaz de hacer frente a Nintendo. Para ello, Microsoft decidió crear dos equipos que compitieran para lograr desbancar a Nintendo: Uno trabajaría con la tecnología que PrimeSense tenía desarrollada ya para aquel entonces, mientras que el otro equipo partiría de la tecnología desarrollada por la compañía 3DV. A pesar de que el objetivo marcado inicialmente era el de presentar alguna novedad en el E3 de 2007, ninguno de los equipos que fueron compuestos había conseguido ningún resultado que mereciera la pena presentar en la convención. Tras la salida de Peter Moore de Microsoft, Don Matrick se hizo cargo de continuar en 17 Figura 4.5: Disposición del dispositivo Wiimote [web14c]. 2008 el proyecto, hasta ahora secreto, de reconocimiento de vídeo a partir de la tecnología de PrimeSense. A pesar de que la tecnología 3DV con la que trabajó uno de los equipos confeccionados inicialmente no obtuvo los resultados esperados, Microsoft decidió comprar la compañía en 2009 por 35 millones de dólares con el fin último de evitar futuros problemas de patentes en torno a Kinect. Posteriormente, Alex Kipman fue ascendido a director general de proyectos de incubación y puesto al cargo de desarrollar un nuevo dispositivo que incluyera un sensor de profundidad, control de movimiento, reconocimiento facial y reconocimiento de voz. Este proyecto fue nombrado con el nombre «Project Natal». Project Natal tomó como referencia el dispositivo desarrollado por PrimeSense, el cual incluía un sensor de infrarrojos y un receptor de infrarrojos. Para evitar futuros problemas, Microsoft decidió obtener la licencia del diseño de dicho dispositivo y del chip PS1080 que montaba. Este chip supuso un paso muy importante para los objetivos del proyecto ya que era capaz de procesar datos de profundidad a 30 frames por segundo de una manera muy innovadora. Este permitió además reducir el precio de reconocimiento de la profundidad en comparación con el método vigente en aquel momento conocido como “tiempo de vuelo”, que consistía en registrar el tiempo que tarda un rayo de en salir y volver al sensor. La solución propuesta por PrimeSense consistía en proyectar un patrón de puntos infrarrojos en las superficies y emplear la disposición de los puntos para confeccionar un mapa de profundidad con una resolución de 320 x 240 píxeles que posteriormente serían analizados por el chip PS1080. Por otra parte, el chip también se encargaba alinear automáticamente la información de la cámara RGB y la cámara de infrarrojos, proporcionando de esta manera datos RGBD. Por su parte, Microsoft equipó también al dispositivo con una matriz de micrófonos de cuatro piezas debido a que ya tenían experiencia con el reconocimiento de voz que incorporaban sus sistemas operativos desde Windows XP. De esta forma, el dispositivo contaría con la capacidad de reconocimiento de voz en grandes habitaciones mediante este 18 micrófono direccional. Si bien el reto del hardware parecía estar resuelto gracias a PrimeSense, sólo a falta de dar con una forma de diseñar un dispositivo más pequeño, los problemas de software que se les estaban presentando parecían insuperables: Debían desarrollar un sistema de reconocimiento de movimiento a partir de los flujos de datos proporcionados por la cámara RGB y el sensor de profundidad que montaba el dispositivo. Debían depurar la señal de audio que proporcionaba la matriz de micrófonos incorporada al dispositivo para hacer posible la implementación de un sistema de reconocimiento de voz. Para tratar de resolver estos problemas de software, el equipo de Project Natal se vio obligado a recurrir a Microsoft Research (MSR), una división de Microsoft que fue creada en 1991 para investigar los diversos temas de ciencia de equipo y problemas. A finales de 2008, el equipo Project Natal contrató a Jamie Shotton para que aportara nuevas ideas para el sistema de seguimiento de movimiento, ya que la solución propuesta hasta el momento contaba con varios problemas: Para conseguir que el sistema de captura de movimiento detectara al jugador era necesario que inicialmente se colocara en posición en forma de T. Cada vez que el jugador detectado era perdido por el sistema era necesario reiniciar el sistema y comenzar de nuevo con la posición en forma de T. El sistema de seguimiento sólo era capaz de funcionar con tipos muy específicos de estructura corporal. No obstante, algunos de los problemas presentados por el seguimiento del movimiento pudieron ser resueltos gracias a los datos de profundidad que eran proporcionados por el sensor de profundidad. Estos permitían hacer un filtrado de los píxeles que no pertenecían al jugador y obtener además información muy valiosa como el color y la textura de la ropa de los jugadores, así como la altura y la anchura del jugador. Como resultado de este primer proceso de filtrado, se obtenía una representación del jugador en posiciones de píxeles, también conocido como “player blob” (ver Figura 4.6). Sin embargo, esto tan sólo supuso la primera parte de la resolución del problema. Por ello, Jamie Shotton tuvo que enfrentarse al reto de de transformar este player blob en algo que pudiera ser seguido. La solución que Shotton propuso consistía en fragmentar el player blob obtenido en partes del cuerpo que fueran fácilmente reconocibles. De esta forma, una vez que estas partes del cuerpo fueran identificadas, sería también posible identificar también las articulaciones y por consiguiente el esqueleto del jugador. Por último, junto con Fitzgibbon y 19 Figura 4.6: Player blob [WA12]. Andrew Blake, Shotton desarrolló un algoritmo que llegaría a ser capaz de diferenciar hasta 31 partes del cuerpo (ver Figura 4.7). Figura 4.7: Player blob dividido en partes [WA12]. Anteriormente se expuso a otro problema muy serio: La necesidad de que el jugador adoptase una posición inicial en forma de T para que el sistema de seguimiento de movimiento fuera capaz de detectar al jugador. Para hacer frente a este problema, Shotton decidió emplear técnicas de aprendizaje por ordenador. De esta forma, mediante cantidades ingentes de datos, el sistema de reconocimiento de imagen podía ser entrenado para dividir el player blob en las partes del cuerpo, de forma que estas pudieran ser utilizadas posteriormente y 20 así evitar esta molesta posición inicial en forma de T. Para lograr este propósito, se colocaron dispositivos en hogares con el objetivo de realizar grabaciones de vídeo de personas realizando movimientos físicos básicos. Toda esta información recolectada, junto con datos adicionales obtenidos en un estudio de captura de movimiento en Hollywood que recogían secuencias de videos de personas corriendo, bailando, etc., fue procesada por un sistema de computación distribuida conocido como Dryad con el objetivo de de producir un clasificador por árbol de decisión. Con este árbol de decisión sería posible asignar cualquier píxel obtenido mediante el sensor de profundidad incorporado en Kinect a una de las partes del cuerpo. Además, este proceso fue realizado para 12 tipos diferentes de cuerpos, solucionando de esta manera otros de los problemas expuestos anteriormente en el que sólo era reconocido un tipo de estructura corporal, realizando además diversos ajustes que permitieran mejorar la capacidad de decisión para identificar una persona sin una pose inicial y sin interrupciones en el reconocimiento. Llegados a este punto, tan sólo les quedaba una tarea pendiente: El reconocimiento por voz. Para hacer frente al reto, Alex Kipman recurrió a Iván Tashev del grupo de investigación de Microsoft en Redmond, ya que previamente había trabajado en proyectos similares para el reconocimiento por voz en Windows Vista. Para abordar el problema del filtrado de ruido de fondo en una matriz de micrófonos que se encontraba situada más cerca de los altavoces del televisor que del propio jugador, debían seguir un planteamiento similar al empleado anteriormente para diferenciar entre los píxeles que pertenecían a un jugador de los que no. Como resultado obtuvieron unos algoritmos de cancelación de ruido y supresión de eco mediante la combinación de las tecnologías ya patentadas por Microsoft que mejoraron el procesamiento de audio situándolo muy por encima del estándar que estaba disponible en la fecha. Por último, se lanzó durante una semana un sistema de aprendizaje computacional distribuido compuesto por mil nodos con el objetivo de construir un modelo acústico para Kinect, finalizado el 26 de septiembre de 2010. Este estaba basado en varios acentos regionales de América y las peculiaridades acústicas de la matriz de micrófonos que poseía Kinect. Finalmente, el 4 de Noviembre de 2010 el sensor fue anunciado bajo el nombre de Kinect. 4.1.2.3. Homebrew de Kinect Este movimiento tuvo importantes repercusiones en el entorno de Kinect como se mostrará a lo largo de esta sección, ya que entre otras cosas dio lugar a la aparición de numerosas plataformas como O PEN NI o NiTE, las cuales son las principales herramientas de este proyecto. La historia “hacker” de Kinect comienza con Johnny Chung Lee. Johnny era ya conocido por aquel entonces por ser la persona que había hackeado el controlador remoto de Wii, 21 Wiimote (véase § 4.1.2.2), con el objetivo de implementar el seguimiento de dedos (ver Figura 4.8) y que posteriormente pasaría a formar parte de Project Natal para trabajar en el reconocimiento de gestos. A pesar de los intentos de Johnny por convencer a Microsoft para publicar un driver público para Kinect, no lo consiguió. Fue por este motivo por el que contactó con AdaFruit, un suministrador de código libre, para convocar un concurso con el fin de hackear Kinect. Figura 4.8: Johnny Lee mostrando las modificaciones al Wii Remote [web14f]. Este concurso, cuyo anuncio coincidió con el día en que se lanzó Kinect al mercado, ofrecía un premio de 1000 dólares (que posteriormente sería aumentado hasta 3000 dólares) al primer participante que logrará desarrollar con éxito un controlador para el dispositivo e implementar una aplicación que convirtiera los flujos de datos del sensor de vídeo y visión de profundidad de Kinect. Este concurso fue posible en gran medida al hecho de que Kinect se comunicaba mediante un USB estándar con la consola Xbox 360 y por tanto ese mismo conector podría ser conectado al puerto USB de cualquier ordenador. A pesar de los comunicados realizados por Microsoft para evitar los objetivos de dicho concurso, el 6 de Noviembre de 2010 Joshua Blake, Sandler Seth, y Machulis Kyle fundaron un grupo de trabajo denominado OpenKinect con el objetivo de coordinar los esfuerzos para ganar el concurso. Ellos consideraban que el primer reto propuesto por el concurso era relativamente sencillo de conseguir pero que, sin embargo, debían aunar todos los esfuerzos realizados con el fin de intercambiar la información que fueran obteniendo y las herramientas que se fueran desarrollando. Lo que comenzó siendo un grupo fundado para conseguir un premio terminó siendo una comunidad centrada en en mirar hacia lo que podría lograrse gracias a la tecnología que ofrecía este nuevo dispositivo. De manera simultanea a estos acontecimientos, AlexP mostró en la red cómo era capaz de controlar los motores que poseía Kinect y leer los datos provenientes de su acelerómetro. 22 Dos días después, publicó un vídeo en el que mostraba cómo obtenía el flujo de datos de la cámara RGB y de la cámara de profundidad. Sin embargo, y a pesar de que el premio de AdaFruit había ascendido ya a 3000 dólares, decidió no proclamarse campeón del mismo debido a sus reticencias de publicar el código. Microsoft siendo consciente de los avances que estaban realizando en la comunidad hacker en su lucha por liberar el dispositivo y ofrecer herramientas para que cualquiera pudiera desarrollar para Kinect, mostró públicamente su cambio de opinión respecto a este movimiento siempre y cuando no se denominara “hackeo”. Fue el analizador USB Beagle 480 (ver Figura 4.9) lo que permitió a AdaFruit comenzar con el volcado USB de los datos recibidos a través de Kinect. Héctor Martín, ingeniero informático de Bilbao, gracias a estos datos fue capaz de desarrollar en unas pocas horas un controlador (libfreenect) y una aplicación para mostrar los datos de la cámara RGB y de la cámara de profundidad. Figura 4.9: Analizador de USB Beagle 480 [web14e]. PrimeSense anunció el 10 de Diciembre el lanzamiento de sus propios controladores de código abierto para el dispositivo y todas las librerías (entre ellas O PEN NI) necesarias para procesar los datos obtenidos del mismo. Este hecho supuso un gran avance, ya que las herramientas que ofrecía PrimeSense mejoraban notablemente los resultados obtenidos con los algoritmos de seguimiento de libfreenect. No obstante, al igual que le ocurrió a Microsoft en un principio, el seguimiento de esqueleto mediante O PEN NI todavía necesitaba la incómoda postura en T para inicializar el reconocimiento de esqueleto. No fue hasta el 17 de junio de 2011 que Microsoft ofreciera oficialmente soporte para desarrollar con Kinect. Para ello lanzó una beta del Software Development Kit (SDK) bajo una licencia pública no comercial. En la actualidad, cualquier desarrollador que lo desee puede obtener acceso a las mismas herramientas que Microsoft utiliza para implementar aplicaciones para Kinect. 23 4.1.3 Desarrollo de aplicaciones alternativas Gracias a las características que serán explicadas en la siguientes subsecciónes (véase § 4.1.4 y § 4.1.6), Kinect ha conseguido desde que fue lanzada su primera versión en 2010 ser mucho más que un simple periférico para videojuegos. Los desarrolladores de todo el mundo han descubierto que posee un gran potencial, permitiéndoles experimentar con un hardware de visión, que generalmente hubiera estado al alcance de unos pocos debido a la complejidad y alto precio. Esto se debe en gran parte a que el controlador de Microsoft es uno de los dispositivos más versátiles del mercado, sobre todo, teniendo en cuenta que originalmente fue desarrollado para ofrecer una nueva forma de interacción a los jugadores de videoconsolas. De este modo, Kinect ha conseguido trascender el objetivo con el que fue creado para llegar a convertirse en una poderosa herramienta de visión por computador que es empleada en prestigiosos centros de investigación como el MIT Media Lab. En una entrevista Joi Ito, director del MIT Media Lab, comentaba que este dispositivo está comenzando a ser la piedra angular de muchos proyectos de investigación desarrollados por estudiantes en el MIT. Algunos de los más interesantes son: Kinect for Cooler Videoconferencing, que consiste en un sistema de videoconferencia que ofrece una forma diferente de interactuar en relación a las plataformas que se conocen hoy en día para tal fin (ver Figura 4.10). Entre los aspectos más destacables en este proyecto se encuentra la posibilidad de emplear realidad aumentada, la identificación de los individuos que se encuentran en escena o incluso el enfoque automático de la persona que se encuentre hablando en cada momento [web14q]. Figura 4.10: Kinect for Cooler Videoconferencing [web14q]. Real-Time Princess Leia Holography Via Kinect Hack (ver Figura 4.11), que consiste en un sistema que permite transmitir vídeo holográfico a quince frames por segundo a través de internet. Lo más llamativo de este proyecto es que para su funcio24 namiento tan sólo se requiere un dispositivo Kinect, un portátil con unas prestaciones estándar para el extremo final de la comunicación y un ordenador de sobremesa que disponga de tres chips de procesamiento gráfico. Para la proyección del holograma se requiere un dispositivo especial para tal propósito y que aún se encuentran en fase de desarrollo [web14x]. Figura 4.11: Real-Time Princess Leia Holography Via Kinect Hack [web14x]. No obstante, desde que se hicieron públicas las herramientas ofrecidas por las diferentes compañías, desarrolladores de todo el mundo comenzaron a crear sus propias aplicaciones y a exprimir las ventajas que ofrece Kinect más allá de los objetivos iniciales para la videoconsola Xbox 360. No obstante, esto supone una oportunidad que va mucho más allá del ocio y proyectos de investigación, convirtiendo a Kinect en la base de muchos productos comerciales. Según declaraciones de miembros de Microsoft: “We’ve seen a tremendous amount of interest in the Kinect for Windows commercial program, with more than 300 companies participating in our early adopter program. Although the commercial hardware and software were not released until February 1 st , we’re already seeing innovative examples of commercial uses from some of our early adopter participants. The possibilities are endless. In coming months, we will feature many of these examples of Kinect for Windows applications on this website as well as our blog.” 25 En las siguientes subseciones se presentan algunos de los start-ups más destacados hasta el momento ordenados por el campo en el que trabajan. 4.1.3.1. Ocio Ubi (ver Figura 4.12), sistema desarrollado por Ubi Interactive que permite convertir cualquier superficie en una pantalla táctil [wbU14]. Figura 4.12: Ubi Interactive [wbU14]. Fitnect (ver Figura 4.13), ofrece un probador en tres dimensiones basado en realidad aumentada. Esta innovadora aplicación permite a los compradores probarse de manera virtual diferentes prendas y accesorios, dándoles así la oportunidad de ver cómo les sentarían los productos sin necesidad de probárselos [web14b]. Figura 4.13: Fitnect [web14b]. 26 4.1.3.2. Medicina TedCas (ver Figura 4.14), sistema desarrollado por TedCas Medical Systems. Su principal objetivo es luchar contra las infecciones que se producen en un quirófano puesto que, gracias a Kinect, permite a los cirujanos navegar por el historial clínico de los pacientes sin necesidad de tocar su historia clínica o el teclado ya que todo será controlado mediante gestos [wbT14a]. Figura 4.14: TedCas [wbT14a]. VirtualRehab (ver Figura 4.15), sistema desarrollado por Virtualware Group el cual se centra en proporcionar un programa de rehabilitación a través del fortalecimiento muscular, la resistencia y la coordinación [wbV14]. Figura 4.15: VirtualRehab [wbV14]. 4.1.3.3. Educación KinectEducation [web14o] es un recurso de la comunidad educadora que tiene el objetivo de impulsar a los desarrolladores, profesores, estudiantes, aficionados y a cualquier otra persona interesada en la educación para promover en las aulas el uso 27 de aplicaciones basadas en Kinect. Ellos defienden que la integración de dispositivos como Kinect en las aulas ofrece innovadoras oportunidades de aprendizaje dentro de un entorno controlado de le educación pública. “River Crossing” es una de las aplicaciones que presentan en esta comunidad. Este juego educativo tiene como principal objetivo que el niño sea capaz de aprender la tarea de dirigir un barco a través de un río donde el niño debe emplear la lógica para trasladar un pato, un zorro y un saco de semillas a la otra orilla del río sin que se coman unos a otros (ver Figura 4.16). “Kinect Math” es otra de las aplicaciones promovidas por KinectEducation, con el objetivo de dar a los educadores la posibilidad de volver a interesar a los estudiantes de matemáticas, practicando físicamente con los conceptos matemáticos que pueden resultar más abstractos (ver Figura 4.17). Figura 4.16: Juego River Corssing [web14i]. Jumpido [web14g] es una plataforma de aprendizaje enfocada en dar soporte al plan educativo de niños entre 6 y 12 años. Para ello, incorpora una gran variedad de actividades que permiten a los niños progresar de manera interactiva y entretenida en diferentes campos como en biología, química, matemáticas, música, etc. “Baskets” es un ejemplo de sus muchas actividades cuyo fin es animar al niño a resolver problemas matemáticos que van apareciendo en las ramas de los árboles dándoles una retroalimentación muy estimulante para ellos sobre sus respuestas (ver Figura 4.18). 4.1.3.4. Accesibilidad Navigational Aids fot the Visually Impaired (NAVI) (ver Figura 4.19): Tiene como objetivo emplear el sensor de profundidad de Kinect para detectar paredes y obstácu28 Figura 4.17: Kinect Math [web14l]. Figura 4.18: Actividad “Baskets” integrada en la plataforma Jumpido [web14g]. los, sirviendo así como ayuda de movimiento para una persona con algún grado de discapacidad visual proporcionándoles feedback táctil sobre los obstáculos que se encuentran en su camino. Fue creada por dos estudiantes de la Universidad de Konstanz en Alemania. La aplicación emplea, además de un dispositivo Kinect, un ordenador portátil y un dispositivo Arduino LillyPad que están situados en una mochila. Por otro lado, el sensor está ubicado en un casco especial sobre la cabeza del usuario, manteniendo de esa forma el sensor Kinect apuntando hacia el frente [web14w]. Kinect Sign Language Translator (ver Figura 4.20): Es un prototipo de investigación desarrollado por la división MSR que es capaz de traducir ambos lenguajes, en ambos sentidos y en tiempo real. El sistema reconoce los gestos, traduciéndolos de forma escrita y oral, mientras que si una persona habla, sus frases se traducen a signos en un modelo en el ordenador. No obstante, el desarrollo aún tiene un largo recorrido por delante ya que se necesita que cinco personas hagan el mismo gesto por cada palabra de forma que luego ésta sea reconocida a posteriori. Por el momento se han incluido 29 Figura 4.19: NAVI (Navigational Aids fot the Visually Impaired) [web14w]. 300 palabras chinas de un total de 4.000 que los programadores chinos están utilizando para las pruebas iniciales. Figura 4.20: Kinect Sign Language Translator [web14r]. 4.1.4 Características técnicas Actualmente hay disponible en el mercado dos versiones diferentes: Kinect for Xbox 360 y Kinect for Windows. Ambos sensores comparten muchas capacidades (ver cuadro 4.2), siendo algunas de las más importantes: Una cámara RGB, la cual hace posible la captura de vídeo mediante el almacenamiento de datos desde tres canales a una resolución de 1280 x 960 a 30 frames por segundo, o a una resolución de 640 x 480 frames por segundo. Un sensor de infrarrojos (IR) y un sensor de profundidad IR. Ambos hacen posible la captura de profundidad: El emisor emite rayos de luz infrarroja y el sensor de profundidad lee los haces IR reflejados que vuelven a él. De esta manera, es posible convertir esta información en datos relativos a la profundidad midiendo la distancia entre el objeto y el sensor. 30 Un micrófono de múltiples matrices. Incorpora cuatro micrófonos para que sea posible grabar audio desde una dirección especifica, encontrar la ubicación del sonido y la dirección de la onda de audio. Dispone de un convertidor analógico-digital de 24 bits incluyendo de eco acústico y supresión de ruido. Un acelerómetro de tres ejes configurado para una gama 2G (donde G es la aceleración debida a la gravedad). De este modo, es posible utilizar el acelerómetro para determinar la orientación actual del sensor. Motor: Este motor es capaz de inclinar el dispositivo en un ángulo de 30◦ por arriba y por abajo del plano horizontal. Elemento Rango Ángulo de visión Rango de movimiento del cabezal (vertical) Velocidad de imagen (flujos de datos de color y profundidad) Resolución por defecto en cámara de profundidad Resolución por defecto en cámara de color RGB Formato de audio 43◦ vertical y 57◦ horizontal ±27◦ 30 frames per second (FPS) VGA (640 x 480) VGA (640 x 480) 16-kHz, 16-bit mono pulse code modulation (PCM) Un array de cuatro micrófonos que incluye conversos analógico a digital de 24 bits integrado con Acoustic Echo Cancellation y Noise Suppression Características de entrada de audio Cuadro 4.1: Especificación técnica Kinect. En la Figura 4.21 se muestra un gráfico que especifica como están distribuidos los diferentes componentes en el interior del dispositivo. No obstante, Kinect for Windows ofrece varias funcionalidades que no están presentes en su primera versión, Kinect for Xbox 360. A continuación se mencionan las más significativas: Near Mode: Permite a la cámara ver objetos que se encuentren delante de ella a una distancia de hasta 40 centímetros sin perder exactitud o precisión. Mientras que Kinect para Xbox 360 reconoce usuarios desde los 0’4 metros a los 4 metros de distancia reconociendo el esqueleto únicamente desde los 0’8 metros a los 4 metros, con este nuevo Near Mode es posible reconocer esqueletos desde los 0’4 metros de distancia 31 Figura 4.21: Distribución de los componentes en Kinect [web14k]. a los 3 metros de distancia del sensor. En la Figura 4.22 se muestra una comparativa entre ambos modos de reconocimiento. Figura 4.22: Distancia para el reconocimiento del esqueleto en Kinect [web14k]. Audio y reconocimiento de voz: Recibe una mejora substancial en su precisión y estabilidad. Cable USB: Asegura la fiabilidad en una amplia gama de ordenadores y mejora la convivencia con otros periféricos USB. Configuración de la cámara: Lo cual proporciona ajustes adicionales, tales como el brillo, exposición, etc. así como un mayor rango de resoluciones disponibles en la cámara RGB y en el sensor de profundidad para proporcionar una mayor precisión. Detección de manos: Permite implementar gestos con las manos como pellizcar para hacer zoom, agarrar, etc. 4.1.4.1. Segunda generación de Kinect Es importante destacar que Microsoft ha anunciado que con motivo del lanzamiento de su nueva videoconsola, Xbox One, Kinect experimentará una importante renovación con grandes mejoras. La gran diferencia del nuevo Kinect (ver Figura 4.23) respecto a su predecesor reside en la nueva cámara principal. La segunda generación del dispositivo de captura de 32 movimientos incorpora una cámara Time-Of-Flight (TOF) de alta resolución que permite al próximo Kinect de Xbox One capturar más detalles con gran precisión y mayor resolución. El nuevo modo de profundidad proporcionado por esta cámara TOF hace posible la captura y la reprodución de una escena con hasta tres veces más fidelidad que el primer Kinect. Figura 4.23: Segunda generación de Kinect [web14k]. No obstante, no es la única ventaja que se obtiene al emplear este tipo de cámara. Con ella además se logra un campo de visión hasta un 60 % más amplio, lo cual permite capturar un espacio mayor, posibilitando de esta manera que más personas puedan ser registradas concurrentemente e incluso a una menor distancia del dispositivo. En la nueva generación de la nueva videoconsola pueden aparecer hasta 6 personas en escena reconociendo y distinguiendo todos sus movimientos. Todos estos cambios suponen un importante avance respecto a su predecesora que tan sólo era capaz de registrar el movimiento de 2. El segundo gran cambio en la nueva generación de Kinect viene de la mano del nuevo sensor de infrarrojos. Este sensor logra reconocer objetos y personas en condiciones de luminosidad muy bajas, siendo ahora tan potente que permite identificar elementos en una habitación totalmente a oscuras. La precisión es tal que permite el reconocimiento de personas y el registro de cuerpos incluso sin ninguna luz visible para el ojo humano. Incluso bajo condiciones de luminosidad bajas permite reconocer la pose de la mano a una distancia de hasta cuatro metros de distancia, distinguiendo con precisión cada uno de los dedos. Mediante la combinación de todas estas novedades es posible registrar no sólo la silueta del usuario, sino también distinguir su esqueleto completo, la orientación de sus miembros, los músculos del cuerpo con la fuerza y distribución de pesos ejercida sobre ellos, y hasta el latido del corazón. El reconocimiento facial también se ve ampliamente mejorado, detectando hasta el más mínimo detalle y gesto, permitiendo de esta manera una identificación más precisa. Esta nueva tecnología cuenta además con una mejora en el procesador de Kinect, permitiéndole hacer frente a la ingente cantidad de información que obtienen todos los nuevos sensores. Hasta 2 gigabits de datos por segundo son recogidos por el dispositivo para leer el entorno. Toda esa información ha de ser procesada e interpretada rápidamente y para ello ha 33 sido necesario una evidente mejora en las especificaciones de la máquina. En resumen, se pueden destacar las siguientes mejoras: Mayor precisión con hasta el triple de fidelidad con respecto su predecesor. Capacidad de ver en la oscuridad gracias a su nuevo sensor IR. Campo de visión hasta un 60 % más amplio. Capacidad de rastrear hasta seis esqueletos a la vez. Detección de frecuencia cardíaca y mejora en la detección de la expresión facial. Veinticinco articulaciones individuales, incluidos los pulgares. A pesar de estas importantes mejoras, el mayor inconveniente para el desarrollo del presente TFG es que no será lanzada hasta hasta el año 2014. Por este motivo, se prevé que para el desarrollo del mismo se emplee la actual Kinect. 4.1.5 Ventajas de Kinect frente a otros dispositivos A continuación se exponen las principales ventajas que el dispositivo Kinect ofrece frente a los dispositivos tradicionales que pueden ser empleados en la visión por computador: Se requiere únicamente una cámara. No son necesarios cálculos manuales para obtener la profundidad. Adquisición de la geometría en tres dimensiones de las escenas en tiempo real. Dependencia de la iluminación reducida. Baja dependencia de la textura de las superficies. En la actualidad existen diversas plataformas muy potentes que ofrecen soporte para desarrollar software para Kinect. 4.1.6 Funcionamiento El propósito de esta sección es proporcionar una visión general sobre la forma en la que trabaja el dispositivo Kinect. Para ello, se ha dividido en diferentes apartados que versan sobre la cámara RGB, la cámara de profundidad y el proceso de mapeo de profundidad, el sistema de micrófonos y por último una breve reseña sobre el motor de inclinación. 4.1.6.1. Cámara RGB Como ya se exponía en la sección de características técnicas de Kinect (véase § 4.1.4), este dispositivo dispone de una cámara RGB que permite capturar vídeo a una resolución de 1280 x 960 frames por segundo o a una resolución de 640 x 480 frames por segundo. Mediante las diferentes plataformas que se encuentran disponibles actualmente (véase § 4.1.8), un desarrollador es capaz de obtener los datos de dicha cámara y emplearlos en 34 sus aplicaciones. Estos datos representan las imágenes que son obtenidas a través del sensor y se encuentran codificados como un vector de bytes. No obstante, para entender esta codificación es necesario conocer primero cómo se estructura una imagen. Cada píxel de una imagen tiene cuatro componentes que representan los valores de los colores rojo (R, red), verde (G, green) y azul (B, blue) más un componente adicional que se corresponde con el valor de transparencia (a, alfa) si se tratan de imágenes RGBa, o un color vacío si es del tipo RGB (ver Figura 4.24). Figura 4.24: Componentes de un píxel. Cada componente de un píxel, a su vez, representa un valor decimal comprendido entre 0 y 255 correspondiendo a un byte. Por lo tanto, el vector de bytes (ver Figura 4.25) que se obtiene del sensor es una representación de esos píxeles organizados de arriba abajo y de izquierda a derecha donde los 3 primeros elementos del vector serán los valores rojo, verde y azul del píxel situado en la esquina superior izquierda de la imagen, mientras que, por el contrario, los 3 últimos elementos corresponderán al píxel situado en la esquina inferior derecha. Figura 4.25: Estructura del vector de bytes de la imagen. 4.1.6.2. Cámara profundidad Como ya se exponía en la sección de características técnicas de Kinect (véase § 4.1.4), este dispositivo dispone de un sensor de infrarrojos (IR) y un sensor de profundidad IR, haciendo posible la captura de profundidad mediante la creación de mapas de profundidad. Este proceso de creación de mapas de profundidad se lleva a cabo mediante lo que se denomina “codificación de luz”. Esta codificación de luz consta de dos fases: Calibración (ver Figura 4.26): Esta fase consiste en la proyección de un patrón de puntos (ver Figura 4.27) sobre una superficie variando la distancia a la que se encuentra en 35 unas posiciones conocidas. Posteriormente, por cada posición se obtiene una imagen infrarroja que será almacenada en la memoria interna del dispositivo y que más tarde servirá como referencia. De esta manera, aplicando técnicas de triangulación y conociendo la distancia que separa el proyector de la cámara infrarroja (75 mm), la focal de ésta (750 mm) y la distancia de la cámara a los puntos proyectados, es posible conocer dónde se proyectaría cada punto en el proyector si este fuese en realidad una cámara infrarroja igual a la otra. Por lo tanto, de esta forma es posible conocer exactamente la posición en la que se proyecta cada punto si se conoce su patrón. Figura 4.26: Fase de calibración del sistema de mapas de profundidad de la Kinect. Funcionamiento(ver Figura 4.28): Esta fase se reduce a un problema de visión estéreo. Para resolver este problema, el chip de PrimeSense que incorpora el dispositivo busca los puntos en la imagen infrarroja para posteriormente comparar la posición de los puntos proyectados (a través de las imágenes de referencia) y la posición de los puntos en la proyección de la imagen que ha sido obtenida, calculando de este modo cuánto se ha desplazado cada punto. Para realizar este proceso, es necesario emplear una matriz de correlación de 9 x 9 píxeles que contiene la disparidad entre los puntos de ambas escenas. Mediante este método se crean unas sombras de 5 píxeles en todo el borde de la imagen debido a que para esos píxeles, parte de la máscara se encuentra fuera de la imagen y por lo tanto no hay información suficiente para realizar la correlación. Posteriormente, mediante un proceso llamado “triangulación activa” se calculan las distancias a las que se encuentran proyectados cada punto. Por último, con 36 Figura 4.27: Imagen de los puntos infrarrojos proyectados en una pared [Bor12]. la información que se ha obtenido de todos los puntos se construye la imagen. En la ecuación 4.1 se observa la ecuación empleada en el proceso de triangulación activa para calcular la profundidad (z), donde b es la distancia entre el proyector infrarrojo y la cámara IR (75 mm), f es la focal de la cámara IR (750 mm); kd es la disparidad entre los puntos de ambas imágenes y doff es la disparidad característica de la Kinect (1090). z= 4.1.6.3. 1 8 b∗f ∗ (dof f − kd) (4.1) Sistema de micrófonos De acuerdo con lo expuesto anteriormente (véase § 4.1.4), Kinect dispone de un sistema de micrófonos que está compuesto de cuatro micrófonos colocados en la parte inferior, uno en el lazo izquierdo y tres en lado derecho (ver Figura 4.29). Esta distribución tan especifica es el principal motivo por el que Kinect dispone de una anchura de 28 cm. Estos micrófonos son empleados tanto para el reconocimiento de voz como para identificar el origen y direccionalidad de la fuente de sonido. Esto último se debe a que el sonido llegará a los distintos micrófonos en instantes de tiempo diferentes, de forma que, a grosso modo, es posible calcular el lugar de dónde provienen las ondas sonoras teniendo en cuenta el desfase entre la señales y la velocidad del sonido en el entorno. 4.1.6.4. Motor de inclinación De acuerdo con lo expuesto anteriormente (véase § 4.1.4), Kinect dispone de un motor de inclinación que se encuentra en su base. El principal objetivo de este motor es permitir mover 37 Figura 4.28: Fase de funcionamiento del sistema de mapas de profundidad de la Kinect. Figura 4.29: Disposición de los micrófonos en Kinect [web14k]. el dispositivo arriba y abajo en un rango de 30 grados con la intención de calibrar el espacio de detección y el ángulo de visión de las cámaras. 38 4.1.7 ¿Por qué Kinect? Las cámaras que normalmente se ven en la vida cotidiana recogen la luz que rebota en los objetos que están delante de ellas y la convierten en una imagen como la que una persona vería con sus propios ojos. Sin embargo, las cámaras de profundidad como la que ofrece Kinect trabaja de una manera muy distinta: Recogen la distancia de los objetos que están situados frente a ellas. Para ello, emplean luz infrarroja para crear una imagen (imagen de profundidad) que no captura la apariencia de los objetos, sino donde se encuentran en el espacio. Una imagen de profundidad es mucho más sencilla de entender por un ordenador que una imagen a color convencional. De este modo, cualquier sistema que intente entender una imagen comenzará analizando los píxeles tratando de encontrar y reconocer las personas y objetos que estos representan. No obstante, esta es una tarea bastante compleja ya que, en una imagen a color, los píxeles están sujetos a varios factores como la luz de la habitación de cuando la imagen fue tomada o la abertura de la cámara. Por el contrario, en una imagen de profundidad el color de cada píxel proporciona la distancia de cada parte de la imagen con respecto la cámara. Puesto que estos valores se corresponden directamente con donde se encuentran ubicados los objetos en el espacio, este tipo de imágenes resultan mucho más útiles y eficientes a la hora de determinar conceptos bastante complejos como por ejemplo dónde comienza un objeto y termina otro o si hay gente alrededor. Además, debido a la forma en la que Kinect captura este tipo de imágenes, los resultados obtenidos no se ven sujetos a las condiciones de luz de la habitación de cuando fue capturada la imagen. De este modo, Kinect capturará la misma imagen de profundidad en una habitación con condiciones de luminosidad opuestas. Por lo tanto, esto proporcionará un entorno más fiable e incluso más fácil de entender por un sistema. En definitiva, gracias a esta información tridimensional que proporciona la cámara de profundidad de Kinect es posible diseñar y construir herramientas más robustas para la detección y seguimiento de personas, así como localizar sus articulaciones y partes del cuerpo. 4.1.8 Librerías Kinect En la siguiente subsección se pretende proporcionar una visión general acerca del estado actual de las diferentes plataformas destinadas al desarrollo de aplicaciones para Kinect: SDK de Kinect, O PEN NI y OpenKinect. Para ello, se han descrito las principales características de cada una, cómo funciona cada framework, las funcionalidades soportadas por cada una, cómo ha evolucionado en los últimos años, así como las ventajas y desventajas que presenta cada una. La documentación requerida para esta subsección ha sido obtenida de diversas fuentes, intentando en todo momento proporcionar la visión más imparcial y objetiva posible. Por ello, se han empleado diversos libros como [KBC+ 12] [Cat12] [KHP11] [WA12] [Mil12] 39 [Dav12] [Jan12] [Fal13], además de las páginas oficiales de cada plataforma y sus correspondientes foros de discusión. 4.1.8.1. SDK Windows El SDK de Kinect es un kit de herramientas ofrecido por Microsoft para el desarrollo de aplicaciones basadas únicamente en el dispositivo Kinect escritas en C++, C#, o Visual Basic. La principal intención de Microsfot con esta plataforma es ofrecer una solución totalmente integrada y que, además, sea fácil de aprender y manejar por los desarrolladores. Para ello, el SDK proporciona una interfaz que permite, de una manera muy sencilla, interactuar con Kinect a través de los drivers que son proporcionados en el mismo SDK y que además permite interaccionar con el sistema operativo y las APIs directamente a través del mismo entorno de desarrollo. 4.1.8.1.1. Descripción del SDK De esta forma, el SDK integra todas las herramientas y APIs que un desarrollador puede necesitar para diseñar e implementar aplicaciones que interactúen con el dispositivo Kinect. Como ya se ha mencionado antes, uno de los objetivos de Microsoft con esta plataforma es ofrecer la solución más sencilla posible a los desarrolladores para que integren el uso de Kinect en sus aplicaciones. Para ello, Microsoft ha ideado el SDK de de forma que el desarrollo de una aplicación con Kinect sea esencialmente igual que el desarrollo de cualquier otra aplicación para Windows, a excepción de que el SDK integra el soporte necesario para las características de la Kinect, como son las imágenes de profundidad y color, entrada de audio, etc. Según la descripción proporcionada por Microsoft, algunos de los ejemplos del tipo de aplicaciones para Windows que se pueden desarrollar empleando la funcionalidad proporcionada por el SDK son los siguientes: Reconocimiento y seguimiento del movimiento de personas mediante seguimiento del esqueleto humano. Determinar la distancia existente entre un objeto y el sensor mediante datos de profundidad. Captura de audio usando mecanismos de cancelación de ruido y eco o encontrar la localización de la fuente donde se origina el sonido. Implementar aplicaciones de procesamiento de voz a través de un motor de reconocimiento del habla. No obstante, no se debe perder de vista otro de los objetivos clave de Microsfot con este SDK: Ofrecer una solución completa y totalmente integrada de forma que un desarrollador tenga a su disposición todo lo requerido para diseñar, implementar y distribuir una aplicación 40 basada en las funcionalidades de Kinect. De esta forma, el paquete distribuido por Microsoft incluye los siguientes componentes: Los drivers necesarios para interactuar con el dispositivo a través de Windows, así como toda la información técnica que es necesaria para desarrollar una aplicación basada en Kinect. Una gran variedad de APIs y fuentes de documentación que sirvan como referencia. Estas APIs ofrecen la posibilidad de recibir una gran variedad de datos multimedia provenientes del sensor con una latencia mínima. Una gran colección de muestras que tienen como objetivo dar a conocer a los desarrolladores un conjunto de buenas prácticas para el uso de Kinect. Un considerable surtido de ejemplos que facilitan el aprendizaje de las APIs. Para el desarrollo de una aplicación a través de este SDK es necesario tener algunas nociones básicas sobre como esta estructurada su arquitectura (ver Figura 4.30): Figura 4.30: Arquitectura del SDK [web14j]. Hardware Kinect: Módulo constituido por los componentes hardware, incluyendo el sensor Kinect y el puerto USB a través del cual se conecta a la computadora. Drivers Kinect: Es la capa software de más bajo nivel que se encarga de comunicarse con el módulo hardware a través de los drivers que son proporcionados con el propio SDK. Estos drivers dan soporte a: • El array de micrófonos como un dispositivo de audio en modo kernel que puede ser accedido a través de las APIs de audio estándar suministradas con el sistema operativo Windows. • Controles especializados para los flujos de audio y vídeo (imágenes RGB, imágenes de profundidad y esqueleto). • Funciones de enumeración de dispositivos que permiten que una aplicación se comunique con más de un dispositivo Kinect. 41 Componentes de audio y vídeo: Compuesta por la Natural User Interface (NUI) de Kinect, encargándose de realizar las tareas de seguimiento del esqueleto y del procesado del audio e imágenes RGB y de profundidad. DirectX Media Objec (DMO): Módulo encargado de la formación de haces provenientes del array de micrófonos, así como de determinar el origen del audio. APIs estándares de Windows 7: APIs de audio, voz y contenido multimedia que están incorporadas en el SDK de Windows 7 (también disponible para Windows 8) y en el SDK de reconocimiento del habla de Microsoft. No obstante, de todos los componentes que forman parte de la arquitectura del SDK de Kinect, el más importante para un desarrollador es NUI ya que constituye el núcleo de las APIs incluidas en el SDK. De entre todas las funcionalidades y los datos que este componente permite acceder, los más destacados son los datos de audio que son transmitidos a través del flujo de audio y los datos RGB y de profundidad de las imágenes que son transmitidas a través de los flujos de RGB y profundidad. En la Figura 4.31 se puede apreciar cuál es esquema de interacción entre el hardware y software de una aplicación a través de NUI. Figura 4.31: Interacción del hardware y software con una aplicación [web14j]. Además de las capacidades hardware que proporciona Kinect, los elementos software incorporados en NUI implementan: Un pipeline software que es capaz de reconocer y realizar el seguimiento del cuerpo humano. Para que esto sea posible, convierte en tiempo de ejecución la información de profundidad obtenida a través de Kinect en la ubicación de las articulaciones del cuerpo humano (ver Figura 4.32). De esta forma, es posible reconocer hasta seis personas personas que se encuentren ubicadas frente a la cámara del dispositivo y realizar el seguimiento de hasta dos. La integración con las APIs de reconocimiento de habla de Microsoft, haciendo posible la incorporación un potente motor de reconocimiento del habla en las aplicaciones. Un ejemplo de ello podría ser la implementación de una aplicación que responda a comandos de voz realizados por el usuario. Actualmente, esta API tiene soporte para doce idiomas, entre ellos el castellano. La integración con el SDK de seguimiento de rostros ofrecido por Microsoft, a través del cual es posible integrar en las aplicaciones funcionalidades que estén basadas en el reconocimiento y seguimiento de caras humanas. Por el momento, las características 42 Figura 4.32: Articulaciones reconocidas por el SDK de Kinect [web14j]. más interesantes de este SDK son la capacidad de detectar hasta 87 puntos del rostro humano (ver Figura 4.33), así como la orientación de la cabeza del usuario. Figura 4.33: Puntos del rostro humano reconocidos por el SDK de Microsoft [web14j]. Otro término importante del SDK de Kinect es el de “KinectInteraction”. KinectInteraction se refiere al conjunto de funcionalidades que permite a las aplicaciones incorporar interacción basada en gestos. Aunque no forma parte del SDK de Kinect para Windows, se encuentra disponible a través de del kit de herramientas asociado a Kinect. Algunas de las funcionalidades de alto nivel que proporciona KinectInteraction son las siguientes: Identificación y seguimiento de las manos de hasta dos usuarios. Servicios para detectar la localización y el estado de las manos del usuario. Detección de la presión ejercida con las manos. Información de control relacionada con los usuarios objetivo. Para que todas estas funcionalidades sean posibles, KinectInteraction emplea una combinación de flujos de profundidad y sofisticados algoritmos. En la figura 4.34 se puede apreciar 43 como está compuesta la arquitectura de este módulo. Figura 4.34: Arquitectura de KinectInteraction [web14j]. Además de todas las funcionalidades proporcionadas a través de las diferentes APIs, el SDK de Kinect incorpora una colección de potentes herramientas que permite a los desarrolladores llevar a sus aplicaciones a un nivel más alto. A continuación se describen las más destacadas: Kinect Studio: Es una herramienta que permite grabar y reproducir secuencias de vídeo de profundidad y RGB capturadas mediante Kinect. Gracias a esta herramienta, los desarrolladores podrán leer y escribir flujos de datos con el objetivo de depurar las funcionalidades de sus aplicaciones, así como para crear escenarios repetibles para realizar labores de testing y análisis de rendimiento. Kinect Fusion: Es una herramienta de gran potencia que en un principio sólo estaba disponible a nivel interno en los equipos de desarrollo de Microsoft. Gracias a esta herramienta, los desarrolladores podrán modelar objetos en tres dimensiones, crear aplicaciones de realidad aumentada e incluso tomar medidas de los escenarios en tiempo real. En la Figura 4.35 se puede observar el proceso de tratamiento que es necesario para conseguir un modelo en tres dimensiones. Figura 4.35: Resultado obtenido a través de Kinect Fusion [web14j]. 44 Plataformas soportadas Requerimientos hardware del computador: Procesadores de 32-bit (x86) o 64-bit (x64). Dual-core con un procesador a 2.66-GHz o superior. Bus USB 2.0 2 GB de RAM. Tarjeta gráfica que soporte DirectX 9.0c Requerimientos software: Visual Studio 2010 o Visual Studio 2012. .NET Framework 4 (incluido en Visual Studio 2010) o .NET Framework 4.5 (incluido en Visual Studio 2012). Sistemas operativos soportados: Windows 7. Windows 8. Windows Embedded Standard 7. Windows Embedded Standard 8. 4.1.8.1.2. Evolución del framework El SDK para Windows fue lanzado por primera vez como una versión Beta el 1 de Junio de 2010, pero debido a la gran aceptación con la que fue recibida, Microsoft decidió el lanzar una segunda versión Beta el 2 de Noviembre de 2011. Es importante destacar que inicialmente ambas versiones del SDK fueron “releases” no comerciales que estaban destinadas a los aficionados. No obstante, la primera versión comercial no se hizo esperar mucho más. Esta fue lanzada bajo el nombre “Kinect for Windows SDK 1.0” en febrero de 2012 junto con la nueva versión de Kinect (Kinect for Windows). En la Figura 4.36 se puede observar la evolución de diferentes versiones hasta el SDK 1.6. La última versión fue lanzada el 17 de Septiembre bajo el nombre de “Kinect for Windows SDK 1.8” con importantes mejoras en el rendimiento de toda la plataforma. Además, se incluyen dos nuevas funcionalidades que abren nuevas puertas a los desarrolladores: Webserver para los flujos de datos de Kinect: Se trata de un componente que dota a las aplicaciones hechas en HTML5 con la capacidad de poder acceder a los datos que Kinect obtiene. De esta manera es posible utilizar las interacciones de Kinect para controlar una aplicación hecha en HTML5. 45 Figura 4.36: Evolución del SDK de Kinect [WA12]. Kinect Background Removal: Consisten en un API que ofrece la funcionalidad de eliminar y/o cambiar el fondo de un usuario traqueado. También ofrece la capacidad de configurar a que usuario se le quiere aplicar el efecto en el caso de que halla más de uno en escena. 4.1.8.1.3. Ventajas y desventajas A continuación se describen los pros y los contras de emplear el SDK desarrollado por Microsoft. Ventajas Permite obtener soporte del mismo fabricante del dispositivo, lo cual suele ser sinónimo de seguridad para el desarrollador. Documentación de gran calidad muy extensa y detallada. Plataforma en continua evolución, con releases del SDK muy frecuentes y de gran calidad. Esto se traduce a un ciclo de liberación relativamente rápido (un ejemplo de ello es que en tan solo en año y medio se han liberado 5 releases) con importantes mejoras y novedades en cada release. Amplia compatibilidad entre las diversas versiones del SDK, es decir, es posible realizar tanto el donwgrade como el upgrade de una aplicación de manera relativamente cómoda y sencilla para el desarrollador. Gran variedad de APIs fáciles de emplear y bien diseñadas. Por lo general, estas APIs ofrecen un buen comportamiento y rendimiento. 46 Permite emplear diversos lenguajes de programación como C/C++ y .NET. Todas las prestaciones se encuentran integradas en el mismo SDK sin necesidad de integrar diferentes módulos para cada funcionalidad. Desventajas Sólo es compatible con el sensor Kinect desarrollado por Microsoft. Por lo tanto, el desarrollador queda atado a que su código sólo pueda ser empleado por este dispositivo. Sólo esta disponible para el sistema operativo Windows de Microsoft. Por este motivo, si el desarrollador desea emplear este SDK desde otras plataformas, el desarrollador debe emplear máquinas virtuales con los inconvenientes que eso conlleva. Fuertemente ligado a las herramientas ofrecidas por Microsoft, como es el caso del IDE Visual Studio. El código no es open source, por lo que el uso del SDK requiere aceptar el acuerdo de licencia de software impuesto por Microsoft. Constituye un ecosistema muy cerrado, por lo que la integración de módulos o middleware de terceros puede resultar una tarea bastante tediosa. Microsoft prohíbe distribuir código con su SDK que utilice o acceda a las características de los sensores de Kinect que no sean porporcionados por el propio SDK. Microsoft prohíbe distribuir aplicaciones de Kinect para Windows para usarlas con un sensor distinto del sensor de Kinect para Windows y sus controladores y software de ejecución asociados. Microsoft prohíbe distribuir código con el fin de que sea ejecutado en una plataforma distinta del sistema operativo Microsoft Windows. Microsoft prohíbe modificar o distribuir el código fuente proporcionado por el SDK. 4.1.8.2. OpenNI Establecido en Noviembre de 2012, Open Natural Interaction (O PEN NI) es un consorcio sin ánimo de lucro que fue formado con el objetivo de promover y estandarizar la compatibilidad e interoperabilidad de la Internación Natural (IN), dispositivos, aplicaciones y middleware. Actualmente, O PEN NI es uno de los frameworks de desarrollo con sensores en tres dimensiones más importantes, siendo además su SDK de código abierto un estándar reconocido para el desarrollo de middleware de visión por computador y soluciones en tres dimensiones. La comunidad O PEN NI proporciona a los desarrolladores una amplia gama de herramientas software, junto con una plataforma de ecosistemas en continua evolución para la colabora47 ción y la promoción de manera efectiva. Para ello abordan el ciclo de vida completo de desarrollo: Descubrimiento: En la comunidad O PEN NI un desarrollador podrá encontrar todo lo que necesita para desarrollar el uso de la tecnología de detección en tres dimensiones incluyendo el apoyo, recursos, tutoriales, software, bibliotecas de middleware, aplicaciones y una plataforma de intermediación activa. Desarrollo: La comunidad ofrece a los desarrolladores una plataforma de código abierto que les permite desarrollar middleware de IN y aplicaciones orientadas a diversos mercados, como son la robótica, la televisión, los videojuegos, ordenadores o dispositivos móviles, la sanidad, etc. Distribución: O PEN NI proporciona a los desarrolladores una plataforma de marketing para mostrar sus innovaciones, abriendo de esta manera la puerta hacia nuevas oportunidades. 4.1.8.2.1. Descripción del framework El framework que ofrece O PEN NI es un framework “open source” bajo una licencia “GNU Lesser General Public License (LGPL)” que proporciona numerosas APIs para el desarrollo de aplicaciones basadas en el paradigma de interacción natural con el usuario, es decir, una interacción basada en los sentidos del ser humano como pueden ser el oído o la vista. Para ello, este framework simplifica la comunicación con una gran variedad de sensores de audio, vídeo y profundidad incorporados en los dispositivos hardware compatibles, como son por ejemplo Kinect o el AXUS Xtion (ver Figura 4.37), donde ambos están basados en el chip PS1080 de PrimeSense. También facilita la comunicación con diversos middlewares de percepción que se encargan de analizar e interpretar los datos que son obtenidos de una escena mediante algoritmos de visión por computador. Un ejemplo de ello podría ser un software que tras recibir imágenes, es capaz identificar la posición de los usuarios que están presentes en la escena. Figura 4.37: AXUS Xtion [web14d]. Como se puede apreciar en la Figura 4.38, este framework proporciona a las aplicaciones una interfaz de comunicación con los diferentes sensores hardware disponibles y, también, 48 con los diferentes componentes middleware que se integren en el framework. Es importante destacar que únicamente proporciona interfaces, por lo que relega la lógica necesaria para cada funcionalidad a los diferentes componentes, sean sensores o middlewares; de este modo, algunas operaciones de la API estarán implementadas por los dispositivos hardware y otras por los diferentes componentes middleware. Así, por ejemplo, el framework proporciona operaciones que permiten obtener el mapa de profundidad (véase § 4.1.6.2) de una escena dada o los datos en crudo de la cámara RGB desde los sensores, cuya lógica estará implementada en el propio sensor. Figura 4.38: Arquitectura del framework O PEN NI 2 [web14u]. De manera análoga, para los diferentes componentes middleware el framework proporciona operaciones que permiten obtener diferentes datos, como por ejemplo la posición del usuario, cuya lógica estará implementada en el propio middleware. De esta forma, los distintos proveedores de hardware y middleware O PEN NI pueden desarrollar su propia implementación de las diferentes funcionalidades provistas por O PEN NI y posteriormente integrarlas en el framework para su utilización. Además, también permite registrar varios componentes que implementen la misma funcionalidad y elegir cuál de ellos utilizar al momento de solicitar los datos. Esta API común provista por O PEN NI lo hace extremadamente flexible para la incorporación de nuevos componentes middleware, así como también para el desarrollo y ejecución de aplicaciones, que pueden utilizar la API de forma trasparente e independiente del dispositivo hardware o sensor que haya generado los datos. Un punto muy positivo de este framework es que, además de todo el soporte que pro49 porciona la comunidad a través de su documentación y sus foros oficiales, ofrece una gran cantidad de ejemplos que facilitan en gran medida los primeros pasos para comenzar a familiarizarse con el entorno. En la última versión del framework, O PEN NI 2.2 Beta, se encuentran los siguientes ejemplos: SimpleRead: Muestra cómo codificar una aplicación de consola que abre un flujo de profundidad y lee los frames recogidos. MultipleStreamRead: Muestra la misma funcionalidad que el ejemplo SimpleRead, pero utilizando tanto el flujo de profundidad como el de color. SimpleViewer: Muestra cómo implementar una aplicación con interfaz gráfica que abre flujos de profundidad y de color mostrándolos por pantalla de forma simultanea. MultiDepthViewer: Muestra cómo implementar una aplicación que abre flujos de profundidad y de color simultáneamente desde varios sensores conectados en el mismo ordenador. EventBasedRead: Muestra la misma funcionalidad que el ejemplo SimpleRead pero usando una API basada en eventos. MWClosestPoint: Muestra cómo desarrollar un nuevo middleware sobre O PEN NI. En este caso concreto analiza muestra de frames pare encontrar el píxel más cercano. MWClosestPointApp: Muestra cómo implementar una aplicación de consola que emplea el middleware MWClosestPoint. ClosestPointViewer: Muestra cómo implementar una aplicación con interfaz gráfica que emplea el middleware MWClosestPoint. Otro aspecto interesante que ha aparecido con la segunda versión del SDK de O PEN NI es que se ha solucionado la incompatibilidad de los drivers que existían hasta entonces entre el driver de este y el que proporcionaba el SDK de Microsoft. No obstante, cada día se está llegando más lejos consiguiendo propuestas muy interesantes, como la presentada por Tomoto S. Washio: “kinect-mssdk-openni-bridge”. Esta solución (ver Figura 4.39) pretende ofrecer un módulo que conecte el SDK de Microsoft con el framework de O PEN NI, permitiendo de esta manera desarrollar aplicaciones que hagan uso de ambas plataformas de manera simultanea. No obstante, es muy probable que en futuras versiones del framework de O PEN NI ambas plataformas sean compatibles por defecto sin necesidad de módulos extra. Plataformas soportadas Hardware soportado: Ordenadores basados en arquitecturas x86: Pentium 4, 1.4 GHz o superiores o AMD Athlon 64/FX 1 GHz o superiores. 50 Figura 4.39: Solución propuesta por Tomoto S. Washio [web14m]. Sistemas operativos soportados: Windows XP (32/64 bits) con SP2 y superiores, Windows 7 (32/64 bits) y Windows 8 (32/64 bits). OSX 10.7 y superiores. Ubuntu 12.04 (32/64 bits) y superiores. Entornos de desarrollo soportados: Microsoft Visual Studio 2008 y 2010. GCC 4.x. NiTE y otros middlewares de interés Actualmente existe una gran variedad de middlewares para O PEN NI. No obstante, uno de los más importantes y conocidos es “NiTE” (el cual será empleado para el desarrollo del presente proyecto). NiTE ha sido desarrollado por PrimeSense (creador del hardware de Kinect), constituyendo uno de los middleware más avanzados y robustos en el campo de visión por computador. Entre los muchos beneficios que los diferencian de otras alternativas disponibles en el mercado, destacan los siguientes: Amplias posibilidades de configuración, ofreciendo una solución flexible y extensible por lo usuarios del estándar definido por O PEN NI. Soporte multiplataforma, estando disponible para Windows, Linux, OS X y Android. Mínima carga de CPU, estando optimizado para arquitecturas ARM x86. Gran escalabilidad. Implementado en C/C++. 51 NiTE se integra perfectamente con O PEN NI, proporcionando una API clara y cómoda de usar. Este middleware implementa potentes algoritmos que trabajan a partir de los datos obtenidos de la cámara RGB, del sensor de profundidad y de los micrófonos que incorpora el dispositivo hardware. De esta forma, permite al desarrollador obtener un mayor nivel de abstracción y realizar funciones muy interesantes. A continuación se muestran algunas de las más destacadas: Localización y seguimiento de manos. Analizador de escena, permitiendo aislar al usuario del fondo. Seguimiento preciso de la ubicación y orientación de las articulaciones de los usuarios. Reconocimiento de varios gestos. Aunque NiTE es el más conocido, no es el único middleware disponible a los desarrolladores para integrar en el framework O PEN NI. Gracias a la filosofía de esta comunidad open source, cada día aparecen nuevos e interesantes componentes creados por desarrolladores del todo el mundo y que son puestos al alzance de todo aquel que quiera utilizarlos. A continuación se exponen brevemente alguno de los más llamativos hasta el momento: 3D Hand (ver Figura 4.40): Middleware desarrollado por Foundation for Research and Technology-Hellas (FORTH) que permite el seguimiento en tres dimensiones de la mano humana, así como su orientación y articulación. Todo ello es posible sin necesidad de realizar ningún proceso previo de calibración ni la necesidad de emplear ningún tipo de guantes especiales [web14h]. Figura 4.40: 3D Hand [web14h]. KScan3D (ver Figura 4.41): Solución desarrollada por LMI Technologies, una empresa líder en escaneo 3D, que proporciona un proceso completo para escanear y procesar 52 datos en tres dimensiones. Para ello, incorpora un editor gráfico que permite escanear, editar, procesar y exportar los datos obtenidos en diferentes formatos, como por ejemplo .obj o .fbx. Figura 4.41: Resultado obtenido con KScan3D [web14a]. SigmaNIL (ver Figura 4.42): Solución propuesta por SigmaRD Computer Vision & Graphics que consiste en un framework para el desarrollo de interfaces de usuario con capacidades de reconocimiento de gran precisión, como los dedos de las manos o formas, así como seguimiento y reconocimiento del esqueleto y de las manos de los usuarios. 4.1.8.2.2. Evolución del framework Como consecuencia de un minucioso análisis de la anterior API de O PEN NI, la versión 1.5, la comunidad fue consciente de que muchas de las funcionalidades que hasta aquel entonces eran incluidas en el framework raramente eran utilizadas por los desarrolladores. Como 53 Figura 4.42: Ejemplo de gesto reconocido con SigmaNIL [web14y]. consecuencia PrimeSense decidió realizar un importante lavado de cara al SDK reduciendo en gran medida la complejidad de la API. El primer y principal cambio que se llevó a cabo fue simplificar la interfaz middleware (ver Figura 4.43). De esta forma, O PEN NI es ahora simplemente un API cuyo único objetivo es llevar a cabo la comunicación entre los diferentes sensores a través de los drivers y las aplicaciones o middlewares de terceros. Con esta nueva arquitectura, los desarrolladores de middleware tan sólo deben ser construidos para ser ejecutados por encima de O PEN NI. Sin embargo, en la anterior versión toda esta funcionalidad era proporcionada directamente por O PEN NI mediante la adicción de plug-in’s, dando como resultado una plataforma mucho más compleja de mantener y un API demasiado difícil de manejar. Figura 4.43: Evolución de la arquitectura O PEN NI [web14u]. El segundo cambio que se realizó fue el de simplificar los tipos de datos, como por ejemplo los mapas de profundidad. Estos en un principio eran mapeados como metadatos, lo cual era mucho más complejo de manipular e interpretar que las actuales matrices de profundidad. También se produjeron otros cambios de gran interés para facilitar su aprendizaje y com54 prensión, como por ejemplo la reducción del numero de clases existentes. De este modo, se pasó de tener más de cien clases complejas, estructuras de datos y enumeraciones a tener poco más de una docena. Como resultado se obtuvo una librería que se centraba principalmente en tan sólo cuatro clases: openni::OpenNI. openni::Device. openni::VideoStream. openni::VideoFrameRef. Finalmente, el último cambio significativo que se produjo fue el de implementar un proceso más eficiente para la notificación de eventos. Hasta aquel momento, los datos capturados por los sensores eran accedidos colocando un bucle alrededor de la función que los proporcionaba. Por el contrario, aunque aún sigue siendo posible realizarlo de la anterior manera, en O PEN NI 2 se ofrecen funciones especiales que reciben un evento cuando un nuevo frame, por ejemplo, es capturado. 4.1.8.2.3. Ventajas y desventajas A continuación se describen los pros y los contras de emplear la segunda versión del SDK de O PEN NI. Ventajas Soporta las últimas generaciones de sensores 3D. Fácil para el desarrollo con una API clara y en continua mejora. Amplia portabilidad y soporte multiplataforma, ya que se encuentra disponible para Windows, Linux y OS X. Código “open source”, distribuído bajo una licencia “GNU Lesser General Public License (LGPL)”. Documentación muy extensa y detallada. Permite programación orientada a eventos. Existe una gran variedad de librerías middleware de terceros: Seguimiento del cuerpo, reconstrucción en tres dimensiones, reconocimiento de objetos, etc. Compatible con otro de los principales SDKs para Kinect, como es el SDK desarrollado por Microsoft. 55 Desventajas El núcleo de la plataforma se encuentra muy fragmentado, ya que la segunda versión del SDK O PEN NI fue separada del middleware NITE. Por este motivo, ahora es necesario emplear dos SDK diferentes para llevar a cabo muchas de las tareas básicas. Pocos lenguajes de programación soportados. Este dato resulta muy curioso ya que la primera versión del SDK O PEN NI ofrecía soporte a C/C++, .NET/C# y Java. No obstante, con la reescritura del núcleo de O PEN NI en su geunda versión de SDK, tan sólo es posible emplear C/C++. Es incompatible con el SDK de OpenKinect. 4.1.8.3. OpenKinect Como ya se menciono anteriormente (véase § 4.1.2.3), OpenKinect es una comunidad abierta de personas interesada en obtener el máximo provecho del hardware de Kinect mediante ordenadores y otros tipos de dispositivos, siempre bajo una licencia Apache 2.0 o GPL2. Esta comunidad, que surge el 6 de Noviembre de 2010 como un grupo de personas interesadas en ganar el concurso propuesto por Johnny Chung Lee y AdaFruit cuyo objetivo era desarrollar un controlador para el dispositivo e implementar una aplicación que convirtiera los flujos de datos del sensor de vídeo y visión de profundidad de Kinect, cuenta ya con más de dos mil miembros que contribuyen día a día ofreciendo su tiempo y esfuerzo. Es importante destacar que su esfuerzo y dedicación fue una pieza clave para la aparición de otras plataformas de desarrollo para Kinect como son el SDK de Windows (véase § 4.1.8.1) y O PEN NI (véase § 4.1.8.2). 4.1.8.3.1. Descripción del framework Su principal y más popular librería es “libfreenect”. Esta librería incluye todo el código necesario para activar, inicializar y comunicar datos con el hardware de Kinect. Se trata de una librería de muy bajo nivel que incluye los drivers necesarios para trabajar con sistemas operativos basados en Windows, Linux y OS X. El API que proporciona ofrece soporte y extensiones para los siguientes lenguajes/plataformas: C. C++. .NET (C# y Visual Basic). Java (Java Native Access (JNA) y Java Native Interface (JNI)). Python. C Synchronous Interface. 56 Además, la librería se comunica con el API de OpenKinect y analiza los datos en crudo que son obtenidos por el dispositivo para proporcionar a los desarrolladores un mayor nivel de abstracción. Aunque la librería se encuentra en continua evolución, aún se sigue trabajando para conseguir o mejorar las siguientes funcionalidades: Seguimiento de la posición de las manos. Seguimiento del esqueleto humano. Procesamiento de datos de profundidad especializados. Cancelación de ruido en el audio. Generación de nubes de puntos. Reconstrucción en tres dimensiones. La actual librería cuenta a día de hoy con una gran variedad de wrappers para facilitar la tarea del desarrollador, como son: Python, C Synchronous, C++, C#, Java JNI, Java JNA, Javascript, Common Lisp y GFreenect (GLib). Por último, tan sólo destacar que la librería cuenta con dos herramientas bastante interesantes. La primera de ellas es “Record”, la cual permite realizar un volcado de los datos obtenidos a través de los sensores de Kinect en diferentes formatos como PPM o PGM. Y la segunda, “Fakenect”, que consiste en un simulador que permite realizar pruebas de las aplicaciones sin necesidad de tener una Kinect. 4.1.8.3.2. Ventajas y desventajas A continuación se describen los pros y los contras de emplear la librería libfreenect desarrollada por la comunidad OpenKinect. Ventajas Soporta una gran cantidad de wrappers y lenguajes de programación. Código “open source”, distribuído bajo una licencia Apache 2.0 o GPL2. Amplia portabilidad y soporte multiplataforma, ya que se encuentra disponible para Windows, Linux y OS X. Desventajas Librería de muy bajo nivel. Pocas funcionalidades implementadas. 57 No tiene soporte. Muy poca documentación. No es compatible con otras plataformas como el SDK de Kinect y O PEN NI. Sólo es compatible con el sensor Kinect desarrollado por Microsoft. Por lo tanto, el desarrollador queda atado a que su código sólo pueda ser empleado por este dispositivo. 4.2 Visión por computador El campo de visión por computador es un área que puede ser considerada relativamente novedosa y que actualmente se encuentra en constante expansión [TV98]. No obstante, este campo retrasó su despliegue hasta hace tan sólo unos cuarenta años debido a las grandes dificultades que se encontraban al procesar las grandes cantidades de información que proporcionaban las imágenes. Es importante destacar que esta rama de la tecnología abarca un amplio espectro de problemas cuyas soluciones normalmente suelen encontrase relacionadas con otras disciplinas como pueden ser el procesamiento de imágenes, la inteligencia artificial, visión robótica, etc. Quizá, este sea el motivo por el cuál no hay definido un estándar que marque los límites entre visión por computador y otras muchas disciplinas. Además, también es posible establecer que hasta el momento no existe una formulación estándar de cómo la visión por computador debería resolver los diversos problemas que se plantean. Muchos de las soluciones que se plantean a problemas concretos y bien definidos aún se encuentran en fase de investigación. No obstante, cada vez existen más métodos que pueden presentar posibles usos comerciales, contribuyendo por lo tanto a popularizar la visión por computador y su muchas aplicaciones. A continuación se comentan algunos de los usos ya explotados de la visión por computador en los diferentes campos en los que ya se encuentran disponibles aplicaciones que empleen esta disciplina: Medicina: En la actualidad hay una gran multitud de aplicaciones médicas que hacen uso de la visión por computador, convirtiéndose en herramientas imprescindibles para diferentes tareas. Una de las más destacadas es la diagnosis de enfermedades ya que mediante el uso de estas herramientas es posible destacar aquellas zonas que resultan de vital importancia en las imágenes que son proporcionadas por sensores y escáneres de diversos tipos como por ejemplo las ecografías. Educación: Se han desarrollado una gran multitud de aplicaciones en este campo con el objetivo de hacer de la enseñanza una tarea más atractiva, dinámica y eficiente. Se podrían mencionar una gran cantidad de ejemplos, pero uno de los más interesantes y que cada vez más gente tiene la oportunidad de utilizar son los libros de realidad aumentada donde es posible interactuar con modelos en tres dimensiones. 58 Entretenimiento: Como ya se viene mencionando en las secciones anteriores, una de las aplicaciones más populares y extendidas que hacen uso de la visión por computador con el objetivo de proporcionar entretenimiento son los videojuegos. No obstante, existen muchas otras aplicaciones que van más allá de los juegos como podría ser el uso de reconocimiento de edificios emblemáticos permitiendo de esta manera obtener información interesante desde un punto de vista turístico. Robótica: Uno de los campos que se encuentra más estrechamente relacionado con la disciplina de visión por computador es la robótica. Ejemplo de ello pueden ser los robots autónomos que requieren de la reconstrucción de escenas y el rastreo de caminos. Accesibilidad: Quizás sea uno de los campos más “pioneros” donde la aplicación de técnicas de visión por computador pueden resultar de gran ayuda. Para ello, cada día son desarrolladas más y más aplicaciones que tienen como principal objetivo el proporcionar una ayuda extra a aquellas personas que sufren alguna discapacidad. Un ejemplo muy ilustrativo de ello podría ser que las personas que padecen problemas de visión sean capaces de esquivar eficientemente obstáculos mediante señales acústicas proporcionadas por un sistema basado en visión por computador. En las siguientes subsecciones se pretende ofrecer una breve recapitulación del trabajo que ha sido realizado para resolver el problema del reconocimiento de acciones humanas desde la perspectiva de la visión por computador. También se presentan algunas técnicas para el reconocimiento de acciones basado en vídeo. 4.2.1 Perspectiva de visión por computador Desde la perspectiva de la visión por computador se han ideado diferentes enfoques que tratan de hacer frente al problema del reconocimiento de acciones humanas. Un ejemplo de ello es el trabajo desarrollado por Roberto Vezzani, Davide Baltieri, y Rita Cucchiara en la Universidad de Modena y Reggio Emilia, Italia. Para resolver este paradigma, proponen un modelo para reconocimiento de acciones basado en Hidden Markov Models (HMM) con un histograma de proyección de características [VBC10]. Según su trabajo, la función de probabilidad de emisión se modela como una mezcla de Modelos de Mezclas Gaussianas (GMM), el cual es uno de los métodos de clustering más empleados y el conjunto de características obtenido de los histogramas de proyección. Estos histogramas contienen el número de píxeles en movimiento para cada fila y columna del frame capturado, proporcionando de esta manera información suficiente para inferir la postura tomada en ese momento por la persona. Entonces, el framework HMM recupera la evolución temporal de las posturas reconocidas englobándolas como una acción global. Francisco Martínez-Contreras, Carlos Orrite-Uruñuela, José Elías Herrero Jaraba, Hossein Ragheb y Sergio A. Velastin proponen en la sexta conferencia Institute of Electrical and Electronics Engineers (IEEE) sobre Advanced Video and Signal Based Surveillance (AVSS) 59 un sistema de reconocimiento de acciones humanas [MCOUHJ+ 09]. En su trabajo tratan de abordar el problema de la modelización y reconocimiento de la acción humana basándose en la silueta, especialmente cuando el numero de muestras de acciones son escasas. El primer paso del sistema que proponen es el modelado en dos dimensiones de las acciones humanas basándose en plantillas de movimiento a través de Motion History Images (MHI). Estas plantillas se proyectan en un nuevo subespacio usando el Kohonen Self Organizing feature Map (SOM), el cual se encarga de agrupar las perceptivas (espacial) y los movimientos (temporal) en un colector principal y de modelar el espacio dimensional en plantillas estáticas. El siguiente paso está basado en HMM con el fin de realizar el seguimiento del comportamiento en secuencias temporales de MHI. Cada nuevo modelo MHI se compara con el mapa de características obtenido durante el entrenamiento. En el caso de que el número de muestras no sea suficiente, se aplica el algoritmo Sampling Importance Resampling (SIR) para incrementar el número de observaciones para el HMM. Finalmente, el patrón de reconocimiento temporal es llevado a cabo por un clasificador Maximum Likelihood (ML). Otro ejemplo es el aprendizaje de acciones humanas a partir de películas propuesto por Ivan Laptev, Marcin Marszalek, Cordelia Schmid y Benjamin Rozenfeld [LMSR08]. El objetivo de su trabajo es abordar el reconocimiento de acciones naturales en diversos entornos realistas. Ellos contribuyen a solucionar el problema de la falta de conjuntos realistas de datos de vídeo investigando cómo podrían ser usados los guiones de cine para la anotación automática de acciones humanas. Para ello, evalúan métodos alternativos para la recuperación de acciones y mostrar los beneficios de un clasificador basado en texto presentando de esta manera un nuevo método para la clasificación de la acciones obtenidas en los vídeos. Este nuevo método aprovecha y amplía varias ideas recientes incluyendo características locales espacio-temporales, pirámides espacio-tiempo y Support Vector Machines (SVM) no lineales. 4.2.2 Algoritmos de reconocimiento de acciones basados en vídeo Los algoritmos de reconocimiento de acciones basados en vídeo se basan, principalmente, en el aprendizaje a partir de ejemplos y técnicas basadas en máquinas de aprendizaje como por ejemplo HMM, reducción dimensional o Bag of Words (B OW). A continuación se exponen algunos de los estudios más destacados. Mohiuddin Ahmad y Seong-Whan Lee en [AL08] presentan un método para el reconocimiento de acciones humanas para secuencias simultaneas de imágenes utilizando una combinación de flujos de movimiento y formas. Con este enfoque, las acciones humanas son representadas como un conjunto multidimensional de flujos ópticos Combined LocalGlobal (CLG) y vectores de características de los límites espacio-temporales de la acción. De esta forma, las acciones son modeladas usando un conjunto de HMM multidimensionales para múltiples puntos de vista mediante las características combinadas. Un de los resulta60 dos más interesantes que se obtienen de su investigación es que fue posible demostrar que el reconocimiento de acciones desde múltiples puntos de vista tuvo una tasa de acierto más elevada que con un único punto de vista. Otro estudio interesante es el realizado por Liang Wang y David Suter que versa sobre el aprendizaje visual y el reconocimiento de los colectores de datos secuenciales con aplicaciones para el análisis de movimiento humano [WS08]. En su estudio se distinguen tres etapas bien diferenciadas para el reconocimiento de acciones humanas: Extraer características simples y fiables de las secuencias de imágenes. Para esta etapa son examinadas dos alternativas: La silueta y la silueta transformada a distancia. Encontrar una representación con una baja dimensionalidad de las características extraídas. Esta etapa es el núcleo del proceso, en el cual es empleado Locality Preserving Projections (LPP), que consiste en una aproximación lineal óptima de una técnica espectral no lineal. Caracterizar y clasificar los movimientos en este espacio de características. Tres métodos muy diferentes son usados para esta etapa: 1) Clasificación basada en GMM; 2) un enfoque basado en la distancia media de Hausdorff y 3) modelado y reconocimiento basado en HMM. En esencia, el objetivo de este estudio es demostrar que mediante el núcleo propuesto en la segunda etapa, junto con los diferentes enfoques de las etapas 1 y 3, es posible resolver los problemas a través de varios tipos de la actividad humana. Chin-Hsien Fang, Ju-Chin Chen, Chien-Chung Tseng, Jenn-Jier James Lien proponen en [FCTL10] el framework Temporal-Vector Trajectory Learning (TVTL) para el reconocimiento de acciones humanas. El concepto más importante de este framework es que intentan añadir información temporal en el proceso de reconocimiento de acciones. Para ello, distinguen tres tipos de información temporal: Locations’ Temporal motion of Mahalanobis distance (LTM), Difference’ Temporal motion of Mahalanobis distance (DTM) y Trajectory Temporal motion of Mahalanobis distance (TTM). Con estos tres tipos de información temporal, el clasificador k-NN basado en la distancia Mahanalobis es capaz de obtener mejores resultados que si se utiliza tan sólo la información espacial. Los resultados que obtuvieron de su estudio sugieren que este metodología es capaz de reconocer con bastante precisión las acciones, especialmente con los parámetros TTM y DTM los cuales obtienen elevadas tasas de precisión incluso en entornos que ofrecen información con un ruido elevado. En [LMN10], Michal Lewandowski, Dimitrios Makris, y Jean-Christophe Nebel introducen un nuevo enfoque para aprender de una forma compacta e intuitiva descriptores de los movimientos del cuerpo humano para el reconocimiento de actividades. Según su estudio, cada descriptor de acción se produce, primero, mediante la aplicación de “Temporal Laplacian Eigenmaps” a los vídeos de vistas dependientes. Después, todos los colectores 61 dependientes de la vista son automáticamente combinados para descubrir una representación unificada que es modelada como un único espacio de tridimensional independiente del estilo y punto de vista. También incorporan una función de mapeo no lineal bidireccional que permite la proyección de acciones entre los espacios originales y embebidos. Los resultados experimentales obtenidos de este estudio demuestran que la robustez en contraposición del estilo y de las variaciones de los puntos de vista proporcionan un método más preciso de reconocimiento de acciones. No obstante, ninguno de los enfoques expuestos anteriormente incluyen capacidades de razonamiento. De este modo, su eficiencia esta basada únicamente en el entrenamiento que reciban y en el alcance de todas las acciones presentes en un escenario determinado. Desafortunadamente, todos estos experimentos de reconocimiento de acciones están dirigidos con vídeos que no son representativos en la vida real, siendo demostrado por el pobre rendimiento obtenido con vídeos capturados en entornos no controlados [LMSR08]. En [KJG+ 11] exponen este problema, partiendo del hecho de que los dataset actuales contienen en el orden de diez categorías de acciones distintas recogidas bajo un entorno controlado. Para tratar de resolver este problema, han recogido en un gran dataset con vídeos de acciones con 51 categorías de acciones. Este contiene alrededor de 7000 clips etiquetados manualmente extraídos de una gran variedad de fuentes que van desde películas hasta vídeos de YouTube. En el Cuadro 4.2 se puede observar una tabla comparativa extraída de dicho estudio. Por último, emplearon este dataset para evaluar el rendimiento de dos sistemas de visión por computador para el reconocimiento de acciones y así explorar la robustez de estos métodos bajo varias condiciones, como por ejemplo movimiento de la cámara, punto de vista, calidad del vídeo y oclusión. Dataset Año Acciones Clips KTH Weizmann IXMAS Hollywood UCF Sports Hollywood2 UCF YouTube Olympic UCF50 HMDB51 2004 2005 2006 2008 2009 2009 2009 2010 2010 2011 6 9 11 8 9 12 11 16 50 51 100 9 33 30-129 14-35 61-278 100 50 min. 100 min. 110 Cuadro 4.2: Conjuntos de datos existentes, el número de categorías y el número de clips por categoría ordenados por año Esta teoría fue reforzada por Jean-Christophe Nebel, Michał Lewandowski, Jérôme Thévenon, Francisco Martínez, y Sergio Velastin en [NLT+ 11]. En dicho estudio concluyeron 62 que actualmente no existen técnicas basadas únicamente en visión por computador y máquinas de aprendizaje que sean realmente eficientes para vídeo en tiempo real en aplicaciones de vigilancia. Para llegar a esta conclusión, evaluaron dos de los escenarios más desafiantes para un sistema de reconocimiento de acciones: Las vistas independientes y las interacciones humanas. De este modo, los frameworks más prometedores, como por ejemplo los métodos de “reducción de dimensionalidad“, “Random Forest“ y B OW, son descritos y evaluados en su estudio empleando conocidos datasets como IXMAS y UT-Interaction. 63 Capítulo 5 Método de trabajo E este capítulo se explicará al lector la metodología de desarrollo empleada para la realización de este proyecto. Se mostrarán también las herramientas, tanto hardware como software, utilizadas en la realización del mismo. N 5.1 Metodología de trabajo Para el desarrollo del presente proyecto se considera que la metodología de trabajo más adecuada y que mejor se adapta a la naturaleza y a las necesidades del mismo es una metodología de desarrollo ágil [Mar03]. Esto se debe principalmente a que uno de los objetivos más importantes es el de minimizar los riesgos que pueden conllevar los plazos de entrega del mismo y el no disponer a priori de una especificación totalmente acotada del sistema, sobre todo al comienzo del planteamiento del mismo. Para conseguir este objetivo, se pretende realizar pequeños desarrollos de software en lapsos cortos de tiempo, también conocidos como iteraciones, dónde lo ideal sería que cada uno durase entre una y cuatro semanas. Cada una de estas iteraciones del ciclo de vida del proyecto deberá disponer de las etapas típicas en desarrollo de software: Planificación. Análisis de requisitos: Entender y comprender de forma detallada cual es la problemática a resolver, verificando el entorno en el cual se encuentra dicho problema, de tal manera que se obtenga la información necesaria y suficiente para afrontar su respectiva solución. Diseño: Una vez que se tiene la suficiente información del problema a solucionar, es importante determinar la estrategia que se va a utilizar para resolver el problema. Codificación: Partiendo del análisis y diseño de la solución, en esta etapa se procede a desarrollar el correspondiente sistema que solucione el problema mediante el uso de una herramienta computacional determinada. Revisión: Realizar las debidas pruebas que garanticen el correcto funcionamiento de dicho sistema bajo el mayor número de situaciones posibles a las que se pueda enfrentar. 65 Documentación: Comunicación escrita en sus diferentes formas, ya sea en enunciados, procedimientos, dibujos o diagramas que se hace sobre el desarrollo de un programa. Sirve para ayudar a comprender o usar un sistema o para facilitar futuras modificaciones. De esta forma, la metodología ágil que más se aproxima a las necesidades del proyecto es Scrum [SB01]. Este enfoque resulta muy atractivo para el desarrollo del proyecto ya que Scrum fomenta la comunicación entre los miembros del proyecto (en este caso, el alumno y los directores del proyecto), evitando de esta manera posibles desvíos durante el desarrollo. Además, Scrum adopta una aproximación pragmática, aceptando de esta manera que el problema no puede ser completamente entendido o definido desde el principio y que la idea inicial sobre el sistema puede ir cambiando o evolucionando, por lo que pueden surgir desafíos impredecibles que pueden no ser fácilmente enfrentados de una forma predictiva y planificada, permitiendo además responder a requisitos emergentes. Como se puede apreciar, en un proyecto dónde gran parte del trabajo reside en la investigación y en la búsqueda de soluciones a problemas aún en fases muy tempranas de su madurez, se ha considerado que esta aproximación resulta verdaderamente acertada e interesante. Para facilitar la comprensión de la planificación que se ha llevado a cabo en el proyecto, en el siguiente subapartado se describen los conceptos más importantes de Scrum así cómo las fases en las que se compone, los roles y responsabilidades de las personas que participan en el proceso y las prácticas seguidas. No obstante, si el lector ya se encuentra familiarizado con el proceso de desarrollo Scrum se recomienda comenzar directamente por la lectura del segundo subapartado (véase § 5.1.2) dónde se describe la planificación llevada a cabo a lo largo del desarrollo del proyecto. 5.1.1 Acerca de Scrum Scrum [ASRW02] es un proceso en el que se aplican de manera regular un conjunto de buenas prácticas para trabajar colaborativamente y obtener el mejor resultado posible de un proyecto. Estas prácticas se apoyan unas a otras y su selección tiene origen en un estudio de la manera de trabajar de equipos altamente productivos. En Scrum se realizan entregas parciales y regulares del producto final, priorizadas por el beneficio que aportan. Por ello, Scrum está especialmente indicado para proyectos en entornos complejos, dónde se necesita obtener resultados pronto, los requisitos son cambiantes o poco definidos o dónde la innovación, la competitividad, la flexibilidad y la productividad son fundamentales. Scrum también está enfocado en dar soporte al desarrollo de sistemas que conllevan diversas variables cómo pueden ser el tiempo, recursos y tecnología y que pueden cambiar a lo largo del proceso. De esta manera, el proceso de desarrollo se convierte en una labor alarmantemente impredecible y compleja, requiriendo flexibilidad para ser capaz de responder a los cambios que puedan ir apareciendo. 66 Además, el proceso Scrum permite mejorar la existencia de prácticas ingenieriles en la organización [MDD10], ya que involucra diversas actividades de gestión orientadas a la identificación de las potenciales deficiencias o impedimentos que aparecen en el desarrollo del proceso, así como las prácticas empleadas. 5.1.1.1. Fases de Scrum La metodología de desarrollo Scrum esta compuesta de tres fases: Pre-game: Esta primera fase está compuesta a su vez por dos subfases conocidas cómo planificación y diseño de alto nivel del sistema. La primera subfase abarca el desarrollo de la especificación del sistema que se pretende desarrollar así cómo la creación del “Product Backlog list”. El Product Backlog list es una lista que contiene los requisitos del proyecto, también conocidos como “historias de usuario” (creadas por el cliente en su propio lenguaje). Además se asigna un orden de prioridad a cada requisito identificado del sistema permitiendo conocer cuáles deberían ser implementados primero y una estimación aproximada del esfuerzo requerido para medir su nivel de dificultad. No obstante, esta lista cambia dinámicamente siendo actualizada continuamente mediante la adicción de nuevos requisitos, limitaciones, herramientas, etc. La segunda subfase, el diseño de alto nivel del sistema, consiste en el desarrollo de un primer diseño de alto nivel sobre el sistema a implementar incluyendo las decisiones de diseño que deben ser aplicadas posteriormente. Development: En esta fase, también conocida cómo fase de desarrollo, se lleva a cabo el proceso de decisión de que historias de usuario van componer cada una de las iteraciones o “Sprints”. Las iteraciones son intervalos de tiempo con una duración aproximada que oscila entre dos y cuatro semanas y que a su vez están compuestas por fases más pequeñas: Análisis, diseño, implementación, pruebas y entrega. Esta fase es iterativa e incremental dónde se van obteniendo las diferentes versiones y módulos del sistema. Por último, es importante destacar que cada una de de las iteraciones llevadas a cabo finalizan con una reunión dónde se analiza si los objetivos marcados al comienzo de la iteración han sido alcanzados y el nivel de satisfacción de los resultados obtenidos. Post-game: Fase final tras haber cumplido los requisitos de entrega pactados al comienzo del desarrollo. Abarca la preparación para el lanzamiento de la versión, incluyendo la documentación final y pruebas antes del lanzamiento de la versión. En la Figura 5.1 se muestra un simple esquema a modo de resumen de cada una de las actividades que se llevan a cabo en cada una de las fases descritas anteriormente con sus correspondientes entradas y salidas. 67 Figura 5.1: Fases de Scrum [web14z]. 5.1.1.2. Roles y responsabilidades Aunque en Scrum se pueden diferenciar hasta seis roles (Scrum Master, Product Owner, Scrum Team, Customer, User y Management) con diferentes propósitos, el presente apartado se centra en la descripción de los principales definiendo cuáles son las responsabilidades de cada uno así como las tareas que deben despeñar: Product Owner: Representa la voz del cliente. Se asegura de que el equipo Scrum trabaje de forma adecuada desde la perspectiva del negocio. El Product Owner escribe historias de usuario, las prioriza y las coloca en el Product Backlog. Scrum Master: Desempeña el rol de administrador dentro del proceso Scrum. Es el responsable de asegurar que el proyecto es realizado de acuerdo a las prácticas establecidas, además de que el proyecto evoluciona según lo previsto. También desempeña el rol de líder del Scrum Team cuando se presenta algún obstáculo y de mantener el equipo de modo que se ocupe de las tareas de la forma más productiva posible. Scrum Team: Pequeño equipo con las habilidades transversales necesarias para realizar el trabajo (análisis, diseño, desarrollo, pruebas, documentación, etc.) y que tiene la responsabilidad de entregar el producto. También poseen la autoridad para decidir sobre las acciones y la organización necesaria para alcanzar los objetivos. Por último, también destacar que están involucrados en la toma de decisiones en cuanto a estimación del esfuerzo. 68 No obstante, existen otros roles auxiliares en los “Scrum Team” que no tienen un rol formal y no se involucran frecuentemente en el proceso Scrum, sin embargo deben ser tomados en cuenta. Un aspecto importante de una aproximación ágil es la práctica de involucrar en el proceso a los usuarios, expertos del negocio y otros interesados (stakeholders). Es importante que esa gente participe y entregue retroalimentación con respecto a la salida del proceso a fin de revisar y planear cada sprint. A continuación una breve descripción: StakeHolders: Hacen posible el proyecto y para quiénes el proyecto producirá el beneficio acordado que justifica su producción. Sólo participan directamente durante las revisiones del sprint. Management: Establecen el ambiente para el desarrollo del producto. 5.1.1.3. Prácticas y conceptos relevantes Cómo ya se anticipaba en lo párrafos anteriores, uno de los principales objetivos del proceso Scrum es hacer frente a los cambios y problemas que puedan ir surgiendo a lo largo del proyecto. Para conseguir este propósito se llevan a la práctica diferentes conceptos para aumentar la comunicación entre los miembros participantes en el proyecto, así como una clara división de los roles que desempeñan cada uno. A continuación se exponen los conceptos más relevantes. Sprint/Iteración Período en el cual se lleva a cabo la mayor parte del trabajo. Aunque lo recomendable es que la duración de los sprints sea constante y definida por el equipo con base en su propia experiencia, es posible comenzar con una duración de sprint en particular (entre 2 y 4 semanas) e ir ajustándolo con base en el ritmo del equipo. Algunas de las actividades más importantes que se deben realizar son las reuniones de planificación de sprints, reuniones diarias y sprint backlog. Al final de cada sprint, el equipo deberá presentar los avances logrados. El resultado obtenido es un producto potencialmente entregable al cliente. Asimismo, se recomienda no agregar objetivos al sprint o sprint backlog a menos que la falta de estos objetivos amenace al éxito del proyecto. En la Figura 5.2 se presenta un pequeño esquema que muestra las diferentes entradas y salidas que se dan lugar en una iteración completa de Scrum. Product Backlog Documento de alto nivel para todo el proyecto que define las descripciones genéricas de todos los requisitos y las funcionalidades deseables que debe contener el producto final basándose en el conocimiento actual que se tiene del mismo. De esta forma, el Product Backlog está compuesto por una lista de requisitos ordenados por la prioridad de los mismos y están acompañados de estimaciones realizadas a grandes rasgos (valor aportado y esfuerzo de desarrollo requerido). Es abierto y sólo puede ser modificado por el Product Owner, representando de esta forma la visión del clien69 Figura 5.2: Iteración de la metodología Scrum [web14z]. te respecto a los objetivos del proyecto. Por último, es importante mencionar que se encuentra en continua evolución y suele ser modificado a lo largo de las iteraciones. Estimación de esfuerzo Realizado por el Product Owner junto con el equipo de desarrollo y consiste en un proceso interactivo dónde se pretende realizar una aproximación del esfuerzo requerido para llevar a cabo cada uno de los elementos descritos en el Product Backlog. Es importante mencionar que las estimaciones tendrán una mayor grado de precisión cuanta mayor sea la cantidad de información que se tenga acerca del proceso a estimar. Aunque existen diversas técnicas para realizar este tipo de procesos de estimación, uno de los más comunes es el juicio de expertos1 . Sprint Backlog Documento detallado que constituye el punto de partida de cada sprint o iteración. Está constituido por los elementos del Product Backlog que deben ser implementados en el presente Sprint y que han sido seleccionados por los miembros del equipos de desarrollo y el Product Owner en la “Sprint Planning meeting”. Es importante destacar que las tareas identificadas son divididas en horas pero que ninguna debe tener una duración superior a dieciséis horas. De este modo, si una tarea es mayor de dieciséis horas, deberá ser dividida en otras menores. Sprint Planning meeting Reunión organizada por el Scrum Master que es realizada al comienzo de cada Sprint. Esta compuesta por dos fases. En la primera el objetivo es definir los objetivos y funcionalidades que deben ser desarrollos en el siguiente Sprint, por lo que participan el cliente, Scrum Master, Scrum Team y administradores. Por el contrario, en la segunda fase tan sólo toman parte el Scrum Master y el Scrum Team con la finalidad de decidir el plan necesario para abordar las tareas planificadas para el 1 Técnica compuesta por un conjunto de opiniones que pueden brindar profesionales expertos en una industria o disciplina, relacionadas al proyecto que se está ejecutando. 70 siguiente Sprint. Daily Scrum meeting Reuniones realizadas diariamente que permiten tener información de seguimiento de primera mano. Deben ser cortas (no más de quince minutos) y son dirigidas por el Scrum Master. A parte de discutir acerca de los problemas que han aparecido, se debe responder a tres preguntas: ¿Qué has hecho desde ayer?, ¿Qué es lo que harás hasta la reunión de mañana? y ¿Has tenido algún problema que te haya impedido alcanzar tu objetivo?. Sprint Review meeting Reunión realizada el último día del sprint en la que el Scrum Master y el Scrum Team presentan los resultados (prototipo) obtenidos al final del Sprint a los interesados (cliente, usuario, administradores, etc.). Además, tras esta reunión se debe haber tratado sobre el trabajo que fue completado y no completado. Importante mencionar que no debe durar más de cuatro horas. 5.1.2 Descripción de la planificación En primer lugar, y antes de proceder a al desarrollo de las diferentes fases que se definen en Scrum, es importante mencionar como se han repartido los roles y responsabilidades durante el desarrollo del proyecto: Product Owner: Este rol será desempeñado principalmente por los directores del proyecto, quienes irán guiando de forma orientativa cuáles son los objetivos a conseguir con el proyecto, requisitos (historias de usuario), etc. No obstante, este rol también puede estar desempeñado por el alumno ya que será la última persona en decidir la dirección que va adoptando el proyecto. Scrum Master: Este rol será desempeñado únicamente por los directores del proyecto. Esto tiene sentido ya que, además de realizar las funciones típicas de un usuario estableciendo los requisitos, también van marcando las pautas necesarias para una correcta evolución del proyecto, resolución de problemas encontrados, desempeño de rol de líder, etc. Scrum Team: Mientras que en la definición original de Scrum el equipo está compuesto de varios integrantes, en el presente proyecto este rol es desempeñado únicamente por el alumno. Respecto a los sprints es importante mencionar que el producto obtenido al final de cada iteración no tiene porque ser estrictamente un módulo del sistema a desarrollar, sino que también debe considerarse cómo producto el conocimiento generado y los conceptos adquiridos, necesarios para la correcto desarrollo del proyecto y la implementación de los diferentes módulos. Por último, tan sólo destacar que los diferentes tipos de reuniones que presenta Scrum, así cómo su frecuencia y duración se han tratado de cumplir lo máximo posible. No obstante, al 71 tratarse un proyecto elaborado a lo largo de un curso académico ha sido necesario compaginarlo con más actividades docentes. De este modo, al igual que ocurre con la duración de los sprints, ha sido necesario adaptarlo a los intervalos de tiempo asignados a esta actividad docente así como a la disponibilidad de los directores. 5.1.2.1. Fase 1: Pre-game El principal objetivo de esta fase es la elaboración del Product Backlog. Para ello, se han definido los requisitos o historias de usuario que debe reunir el proyecto a un nivel de abstracción considerablemente elevado. La motivación de esto se debe a que al proyecto contiene diversas tareas de investigación y, por tanto, no se conocen a priori todos los aspectos que pueden surgir durante su desarrollo, las técnicas que se van a emplear ni resultados que se van obtener. Estos requisitos quedan definidos en el capítulo de Objetivos (véase § 2). No obstante, a continuación se muestra un listado de ellos junto con la correspondiente estimación del esfuerzo requerido: Evaluación de mercado: Primer objetivo ya que en función de los resultados obtenidos se determinará que dispositivo se empleará para realizar el proceso de capturas de imágenes. El esfuerzo requerido para cumplimentar este requisito es principalmente de labores de documentación y, por lo tanto, el tiempo estimado estará sujeto a la cantidad de información disponible. Análisis de librerías disponibles: El esfuerzo requerido para cumplimentar este requisito es principalmente de labores de documentación y, por lo tanto, el tiempo estimado estará sujeto a la cantidad de información disponible, dificultad de las diferentes librerías, etc.). Identificación y análisis de los datos recogidos por el dispositivo: El esfuerzo requerido para cumplimentar este requisito supone la adquisición de habilidades técnicas y conceptos de diferentes ámbitos (procesamiento de imágenes, concurrencia de procesos, conceptos hardware del dispositivo elegido, etc.) Identificación y análisis del conjunto de acciones a reconocer: El esfuerzo requerido para cumplimentar este requisito supone labores de documentación y pruebas mediante el módulo de captura de imágenes que haya sido desarrollado. Adaptación del modelo Bag of Words: El esfuerzo requerido para cumplimentar este requisito supone labores de documentación para comprender el funcionamiento de dicho modelo. También será necesario investigar y analizar las diferentes herramientas necesarias para su funcionamiento, así como estudiar la forma de abordar la integración de la solución proporcionada. Desarrollo de un clasificador (SVM): El esfuerzo requerido para cumplimentar este requisito supone la documentación sobre el funcionamiento sobre este tipo de elemen72 tos software, además de la adquisición de las habilidades técnicas necesarias para su implementación. Organización del conjunto de sujetos del experimento: El esfuerzo requerido para cumplimentar este requisito supone la programación, coordinación y convocatoria de los sujetos que participarán en el experimento. También incluye labores de documentación necesarias para la elaboración de los escritos pertinentes sobre la protección de datos personales, preparación del entorno, etc. Integración de los diferentes módulos: El esfuerzo requerido para cumplimentar este requisito supone la realización de pruebas para comprobar el correcto funcionamiento del sistema desarrollado. Desarrollo de una interfaz gráfica: El esfuerzo requerido para cumplimentar este requisito supone la documentación de las plataformas existentes para este cometido, estudio de su adecuación y la adquisición de las habilidades técnicas para su utilización, además de abordar la integración de los diferentes módulos desarrollados a lo largo del proyecto así como la realización de las pruebas pertinentes para la comprobación del correcto funcionamiento del sistema desarrollado. 5.1.2.2. Fase 2: Development Para la realización de la segunda fase del proyecto, se ha seguido una aproximación basada en lo descrito anteriormente en la sección de “Acerca de Scrum” (véase § 5.1.1). De esta forma, se ha dividido esta fase en seis iteraciones bien diferenciadas pero fuertemente dependientes entre ellas. A continuación se describe cada una junto con su correspondiente Sprint Backlog. 5.1.2.2.1. Iteración 0 Esta primera iteración tiene como objetivo general recoger y analizar la documentación necesaria para comenzar con el proyecto. De esta forma, el Sprint Backlog de esta iteración comprende los siguientes elementos de alto nivel del Product Backlog: “Evaluación de mercado” y “Análisis de librerías disponibles”. A continuación se presenta el Sprint Backlog desglosado en tareas de bajo nivel: Recoger la documentación relativa sobre la historia y evolución de Kinect. Recoger la documentación relativa sobre el desarrollo de aplicaciones alternativas en diferentes campos: Ocio, medicina, educación, accesibilidad, etc. Recoger y analizar detalladamente las características técnicas de las diferentes versiones de Kinect (Kinect para Xbox360, Kinect para Windows y nueva generación de Kinect). Realizar un estudio sobre las ventajas que ofrece Kinect frente a otros dispositivos. 73 Recoger y analizar la documentación relativa sobre el funcionamiento interno de Kinect y realizar un pequeño estudio. Realizar un estudio de mercado de las librerías disponibles. Esta tarea incluye el análisis de las diferentes posibilidades, su evolución en los últimos años y principales ventajas y desventajas frente a otras posibilidades. Recoger la documentación relativa sobre el estado del arte de visión por computador. Realizar un breve estudio sobre los algoritmos existentes para el reconocimiento de acciones basados en vídeo. Los resultados obtenidos de las tareas y requisitos descritos en el Sprint Backlog y la documentación generada en la presente iteración quedan recogidos en el capítulo de “Antecedentes” (véase § 4). 5.1.2.2.2. Iteración 1 Para llevar a cabo la tarea “Identificación y análisis de los datos recogidos por el dispositivo” del Product Backlog ha sido necesario segmentar el trabajo en tres iteraciones (Iteración 1, Iteración 2 e Iteración 3). Esto se debe principalmente a dos motivos. El primero de ellos debido a la gran cantidad de trabajo que abarca esta tarea general y, en segundo lugar, debido a la gran cantidad de nuevos conceptos que implica la realización de la tarea. Para afrontar este reto se ha decido comenzar afianzando los conceptos más generales en la primera iteración, para continuar en las siguientes iteraciones con conceptos más específicos según la problemática que se esté tratando. El objetivo general de esta iteración es realizar la primera toma de contacto con Kinect, permitiendo así familiarizarse con los aspectos más relevantes sobre el dipositivo. De este modo, el Sprint Backlog de la Iteración 1 queda desglosado en las siguientes tareas: Instalación y configuración de los drivers de Kinect, de la plataforma O PEN NI y del middleware NiTE. Instalación y configuración de la herramienta “Processing” y de la librería “SimpleOpenNI”. Comprender y afianzar los conceptos de reflexión, oclusión y desalineamiento entre cámaras. Comprender y afianzar los conceptos relacionados con los píxeles RGB y de profundidad. Comprender el funcionamiento necesario para la conversión a distancias reales. Comprender y afianzar los conceptos relacionados con las nubes de puntos. Entender el funcionamiento de los conceptos adquiridos mediante pequeños ejemplos en Processing (Dibujando con Kinect, Álbum de fotos y Batería virtual). 74 Los resultados obtenidos de las tareas y requisitos descritos en el Sprint Backlog y la documentación generada en la presente iteración quedan recogidos en la sección “Primeros pasos con Kinect” (véase § 6.1). 5.1.2.2.3. Iteración 2 En esta iteración se continua con la tarea “Identificación y análisis de los datos recogidos por el dispositivo” del Product Backlog. De esta forma, los principales objetivos de esta iteración son comprender los conceptos más importantes acerca del funcionamiento de O PEN NI, de la librería GLUT y obtener una primera versión “entregable” del módulo de captura de imágenes. A continuación se presenta el Sprint Backlog de la Iteración 2 desglosado en las siguientes tareas: Comprender y afianzar los conceptos más importantes acerca del funcionamiento de la plataforma O PEN NI. Comprender y afianzar los conceptos más importantes acerca del funcionamiento de la librería GLUT. Realizar la implementación de la primera versión del módulo de captura de imágenes. Esta primera versión debe permitir realizar las siguientes acciones: • Captura del flujo de datos de la cámara RGB. • Captura del flujo de datos del sensor de profundidad. • Visualizar los flujos de datos a través de una interfaz de usuario que implemente los comandos básicos para su control. Los resultados obtenidos de las tareas y requisitos descritos en el Sprint Backlog y la documentación generada en la presente iteración quedan recogidos en la sección “Comprendiendo el funcionamiento de OpenNI” (véase § 6.2). 5.1.2.2.4. Iteración 3 En esta iteración además de continuar y finalizar la tarea “Identificación y análisis de los datos recogidos por el dispositivo”, se lleva a cabo la tarea “Identificación y análisis del conjunto de acciones a reconocer” del Product Backlog. De este modo, el principal objetivo de esta iteración es obtener una versión definitiva del módulo de captura de imágenes. A continuación se presenta el Sprint Backlog de la presente iteración desglosado en tareas de bajo nivel: Comprender y afianzar los conceptos más importantes acerca del funcionamiento del middleware NiTE: Seguimiento de de manos y del cuerpo y detección de gestos. Análisis e interpretación de la información proporcionada por el middleware. 75 Integrar las funcionalidades proporcionadas por el middleware NiTE en el módulo de captura de imágenes. Para ello ha sido necesario realizar tres nuevas versiones de forma iterativa e incremental de la primera versión existente que fue desarrollada en la iteración anterior. En cada una de las diferentes versiones se introducen nuevas funcionalidades así como mejoras en el rendimiento y consumo de memoria. Para llevar a cabo esta tarea se han definido las siguientes subtareas: • Comprender y afianzar el concepto de “background substraction”. • Recoger la documentación relativa sobre el formato de imágenes PPM. • Recoger la documentación relativa y obtener las habilidades técnicas para el manejo de hilos de la librería POSIX. • Identificar, analizar y diseñar los diferentes tipos de hilos ha implementar para mejorar el rendimiento del módulo de captura de imágenes. • Análisis y estudio del impacto producido por el excesivo consumo de memoria y las soluciones existentes para su resolución. • Recoger la documentación relativa sobre el formato de imágenes JPEG. • Recoger la documentación relativa y obtener las habilidades técnicas para el manejo de la librería OpenCV para la comprensión de imágenes en formato JPEG. • Realizar un estudio de mercado de las librerías XML disponibles. Esta tarea incluye el análisis de las diferentes posibilidades. • Recoger la documentación relativa y obtener las habilidades técnicas para el manejo de la librería XML elegida. Los resultados obtenidos de las tareas y requisitos descritos en el Sprint Backlog y la documentación generada en la presente iteración quedan recogidos en la sección “Incorporación de NiTE” (véase § 6.3). 5.1.2.2.5. Iteración 4 Esta iteración tiene como objetivo general la adaptación del sistema de reconocimiento facilitado al módulo de reconocimiento de acciones del proyecto. De esta forma, el Sprint Backlog de esta iteración comprende los siguientes elementos de alto nivel del Product Backlog: “Adaptación del modelo Bag of Words” y “Desarrollo de un clasificador (SVM)”. A continuación se presenta el Sprint Backlog desglosado en tareas de bajo nivel: Recoger la documentación pertinente, analizar y comprender de forma exhaustiva el modelo de Bag of Words (B OW) y todos los conceptos relacionados. Adaptación de la solución propuesta. Para llevar a cabo esta tarea han sido necesarias las siguientes subtareas: • Recoger la documentación relativa y obtener las habilidades técnicas para el manejo de las herramientas ffmpeg, stipdept, Ann y bsvm. 76 • Recoger la documentación relativa y obtener las habilidades técnicas para el manejo del lenguaje de programación PERL. • Documentar y analizar el dataset público de acciones IXMAS. • Recoger y analizar la documentación relativa sobre las principales técnicas de extracción de características en vídeos. • Recoger y analizar la documentación relativa sobre las principales técnicas de clustering. • Recoger y analizar la documentación relativa sobre las principales técnicas de clasificación, especialmente SVM. • Realizar un estudio de mercado de las librerías SVM disponibles. Esta tarea incluye el análisis de las diferentes posibilidades. Los resultados obtenidos de las tareas y requisitos descritos en el Sprint Backlog y la documentación generada en la presente iteración quedan recogidos en la sección “Módulo de reconocimiento de acciones” (véase § 6.4). 5.1.2.2.6. Iteración 5 Esta iteración tiene como objetivo general el desarrollo de una interfaz de gráfica que facilite la utilización de los módulos desarrollados en las iteraciones anteriores mediante un panel de control que permita manipular todas las opciones implementadas de una forma sencilla e intuitiva. Además, también debe facilitar que el usuario pueda emplear todas las herramientas sin necesidad de emplear aplicaciones externas, centralizando en una única aplicación todos los módulos desarrollados. Por tanto, el Sprint Backlog de esta iteración comprende los siguientes elementos de alto nivel del Product Backlog: “Desarrollo de una interfaz gráfica” e “Integración de los diferentes módulos”. A continuación se presenta el Sprint Backlog desglosado en tareas de bajo nivel: Realizar un estudio de mercado de las librerías disponibles para el desarrollo de interfaces gráficas. Esta tarea incluye el análisis de las diferentes posibilidades. Recoger la documentación relativa y obtener las habilidades técnicas para el manejo de la herramienta seleccionada. Diseño e implementación de una interfaz gráfica adecuada para realizar la captura de vídeo mediante la integración del módulo de captura de vídeo. Diseño e implementación de una interfaz gráfica adecuada para realizar el etiquetado de vídeos. Diseño e implementación de una interfaz gráfica adecuada para realizar el proceso de clasificación mediante la integración del módulo de de reconocimiento. 77 Diseño e implementación de una interfaz gráfica adecuada que permita de forma sencilla e intuitiva inspeccionar los resultados obtenidos. Los resultados obtenidos de las tareas y requisitos descritos en el Sprint Backlog y la documentación generada en la presente iteración quedan recogidos en la sección “Interfaz gráfica” (véase § 6.5). 5.1.2.3. Fase 3: Post-game El principal objetivo de esta fase consiste en la realización de las pruebas pertinentes para comprobar el correcto funcionamiento e integración de los módulos implementados en la fase de desarrollo y el respectivo análisis de los resultados obtenidos (véase § 7). Además, también se lleva a cabo la finalización de la documentación generada a lo largo del proyecto. Por último, es realizado el proceso de revisión final del proyecto y se prepara el producto obtenido para su posterior presentación al cliente o usuario final. En este caso, cómo se trata de un proyecto académico este rol será interpretado por el correspondiente tribunal académico. 5.2 Herramientas En este apartado se mostrarán las distintas herramientas, tanto hardware como software, que han intervenido en la elaboración de K IN B EH R. 5.2.1 Aplicaciones de desarrollo Processing: Entorno de desarrollo integrado de fácil utilización, y que sirve como medio para la enseñanza y producción de proyectos multimedia e interactivos de diseño digital [pro14]. Fue iniciado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics and Computation Group del MIT Media Lab dirigido por John Maeda. Se distribuye bajo la licencia GNU GPL. Shell: Programa informático cuya función consiste en interpretar órdenes. Incorpora características tales como control de procesos, redirección de entrada/salida, listado y lectura de ficheros, protección, comunicaciones y un lenguaje de órdenes para escribir programas por lotes o “scripts”. Fue el intérprete usado en las primeras versiones de Unix y se convirtió en un estándar de facto. Open Natural Interaction (O PEN NI): Framework “open source” bajo una licencia “GNU Lesser General Public License (LGPL)” que proporciona numerosas APIs para el desarrollo de aplicaciones basadas en el paradigma de interacción natural con el usuario mediante la utilización de diversos dispositivos hardware, entre ellos Kinect. NiTE: Uno de los middleware más avanzados y robustos en el campo de visión por compu78 tador. Fue desarrollado por PrimeSense (creador del hardware de Kinect). SimpleOpenNI: Es un wrapper basado en el framework O PEN NI y el middleware NiTE que permite desarrollar aplicaciones para Processing [sim14]. OpenCV: Es una biblioteca libre de visión artificial originalmente desarrollada por Intel. OpenCV [ope14] es multiplataforma, existiendo versiones para GNU/Linux, Mac OS X y Windows. Contiene más de 500 funciones que abarcan una gran gama de áreas en el proceso de visión, como reconocimiento de objetos (reconocimiento facial), calibración de cámaras, visión estérea y visión robótica. Se encuentra distribuida bajo licencia BSD lo cual permite que sea usada libremente para propósitos comerciales y de investigación con las condiciones en ella expresadas. Implementada en C y C++. OpenGL Utility Toolkit (GLUT): Es una biblioteca de utilidades para programas OpenGL que principalmente proporciona diversas funciones de entrada/salida con el sistema operativo [glu14]. Entre las funciones que ofrece se incluyen declaración y manejo de ventanas y la interacción por medio de teclado y ratón. También posee rutinas para el dibujado de diversas primitivas geométricas que incluyen cubos, esferas y teteras. También tiene soporte para creación de menús emergentes. La versión original de GLUT fue escrita por Mark J. Kilgard. GNU Compiler Collection (GCC): Colección de compiladores del proyecto GNU [gcc14]. GNU Make: Herramienta para la generación automática de ejecutables [SMS04]. Mercurial: Sistema de control de versiones distribuido. Se ha hecho uso de esta herramienta para el código del proyecto y la documentación [mer14]. Stipdet: Es una aplicación desarrollada por Ivan Laptev cuya finalidad es calcular los descriptores para cada uno de los puntos de interés espacio-temporal del vídeo que le es pasado como argumento [sti14]. ANN: Es una librería escrita en C++ destinada a ofrecer estructuras de datos y algoritmos para el cálculo de la búsqueda de vecinos próximos en ámbitos que presentan un elevado número de dimensiones [ann14]. BSVM: La implementación actual de BSVM toma prestada la estructura interna de LIBSVM 2 ofreciendo de este modo opciones muy similares [bsv14]. ffmpeg: Colección de software libre que puede grabar, convertir (transcodificar) y hacer streaming de audio y vídeo [ffm14]. Incluye libavcodec, una biblioteca de códecs. El proyecto comenzó por Gerard Lantau, un seudónimo de Fabrice Bellard, y ahora es mantenido por Michael Niedermayer. 2 Software integrado para la clasificación del vector de la ayuda, (C-SVC, NU-SVC), la regresión (épsilonSVR, NU-SVR) y la valoración de la distribución (uno-clase SVM). 79 Qt: Biblioteca multiplataforma de software libre y código abierto usada para desarrollar aplicaciones con interfaz gráfica de usuario [qt14], así como también para el desarrollo de programas sin interfaz gráfica, como herramientas para la línea de comandos y consolas para servidores. Qt es utilizada en KDE, entorno de escritorio para sistemas como GNU/Linux o FreeBSD, entre otros. Qt utiliza el lenguaje de programación C++ de forma nativa, adicionalmente puede ser utilizado en varios otros lenguajes de programación a través de bindings. GNU Emacs: Entorno de desarrollo de GNU que ha sido empleado tanto para realizar la implementación así como para la documentación [ema14]. 5.2.2 Lenguajes de programación Para la elaboración del presente proyecto ha sido necesario la utilización de diversos lenguajes de programación. A continuación se muestra la lista completa de todos ellos: C++: Creado por Bjarne Stroustrup [Str00], C++ proporciona mecanismos de orientación a objetos y compatibilidad con C. Es un lenguaje compilado que ofrece distintos niveles de abstracción al programador. Perl: Diseñado por Larry Wall en 1987. Perl toma características del lenguaje C, del lenguaje interpretado bourne shell (sh), AWK, sed, Lisp y, en un grado inferior, de muchos otros lenguajes de programación. Estructuralmente, Perl está basado en un estilo de bloques como los del C o AWK, y fue ampliamente adoptado por su destreza en el procesado de texto y no tener ninguna de las limitaciones de los otros lenguajes de script. Processing: Un lenguaje de programación de código abierto basado en Java. Se distribuye bajo la licencia GNU GPL. 5.2.3 Documentación y gráficos LATEX: Lenguaje de marcado de documentos de carácter técnico y científica, utilizado para realizar este documento [Tal13]. BibTex: Herramienta para la descripción de referencias para documentos escritos con LATEX. Dia: Editor de diagramas [dia14]. Se ha utilizado para construir los diagramas de clases, de flujo, etc. Gimp: Software de edición de imágenes y retoque fotográfico. Utilizado en la maquetación de fotografías e ilustraciones [gim14]. 5.2.4 Hardware Ordenador de sobremesa: Para el desarrollo de K IN B EH R se ha empleado un equipo de sobremesa. Este equipo cuenta con las siguientes características: 80 Intel(R) Core(TM) i7-2620M CPU @ 2.70GHz. 4 GB de RAM. 500 GB Disco Duro. Kinect para Xbox360: Es “un controlador de juego libre y entretenimiento” creado por Alex Kipman, desarrollado por Microsoft para la videoconsola Xbox 360, y desde junio del 2011 para PC a través de Windows 7 y Windows 8.3. Tratado en mayor profundidad en el capítulo de antecedentes (véase § 4). Disco duro externo de 1 TB 5.2.5 Sistemas operativos Debian: Se ha empleado Debian 7.0 (wheezy) 64-bit con núcleo Linux 3.0.0-1-amd64, instalado en el equipo de sobremesa indicado en la sección § 5.2.4, como sistema operativo principal para la realización del presente proyecto. 81 Capítulo 6 Desarrollo del proyecto E el presente capítulo se describe el proceso de desarrollo que se ha llevado a cabo para la realización del proyecto. Para ello, se ha estructurado su narración en varias secciones tratando de ser lo más fiel posible a las diferentes etapas que se han llevado a cabo a lo largo del proyecto. En cada una de estas secciones se describen los conceptos más importantes que se han ido adquiriendo a lo largo del proyecto así como todo aquello que se ha considerado relevante para la correcta comprensión y seguimiento del mismo. N Al tratarse del capítulo más extenso, se ha decidido incluir a continuación una breve guía para facilitar al lector su seguimiento. El capítulo se encuentra dividido en cinco grandes bloques, coincidiendo de esta manera con las iteraciones propuestas en la planificación, en los que se tratan los siguientes aspectos: Primeros pasos con Kinect: Presenta conceptos de relevancia para la realización del proyecto relacionados con el tratamiento e interpretación de imágenes, prestando especial atención a las peculiaridades de Kinect. A lo largo de este bloque se exponen diferentes ejemplos para apoyar los conceptos tratados y para familiarizarse con Kinect mediante la utilización de una librería de alto nivel. Comprendiendo el funcionamiento de O PEN NI: En este bloque se tratan los aspectos más relevantes sobre la bibliotecas empleadas, O PEN NI y GLUT. No obstante, si el lector se encuentra familiarizado con estos conceptos se recomienza comenzar su lectura por la sección “Primera versión del módulo de captura de imágenes” (véase § 6.2.3). En esta sección se narra como se ha llevado a cabo la implementación de la primera versión del módulo de captura de imágenes. Incorporación de NiTE: En este bloque se introducen los conceptos más importantes sobre el middleware NiTE. Algunos de los temas tratados son el seguimiento de manos y detección de gestos, su funcionamiento y el análisis e interpretación de la información proporcionada. No obstante, si el lector se encuentra familiarizado con estos conceptos se recomienza comenzar su lectura por la sección “Evolución del módulo de captura de imágenes” (véase § 6.3.2). En esta sección se narra como se ha llevado a cabo la implementación de las siguientes versiones del módulo de captura de imágenes. 83 Módulo de reconocimiento de acciones: Este bloque se encuentra dividido en dos partes bien diferenciados. En la primera de ellas se presentan los conceptos y aspectos más importantes y que se han tenido en cuenta sobre B OW. No obstante, si el lector se encuentra familiarizado con estos conceptos se recomienza que comienze la lectura por la segunda parte “Implementación de la solución propuesta” (véase § 6.4.2) Esta segunda parte describe detalladamente cada una las fases en las que se ha dividido el proceso de reconocimiento de acciones así como la forma en la que se ha procedido para adaptar la solución facilitada. Interfaz gráfica: Este último bloque versa sobre el proceso seguido para el desarrollo de una interfaz gráfica que permita integrar todos los componentes desarrollados a lo largo del proyecto. Además, para facilitar al lector la lectura del capítulo y evitar la complicación de su correcto seguimiento, se ha decidido dejar la descripción sobre la planificación efectuada y la descripción de la metodología de desarrollo seguida en el capítulo anterior (véase § 5). 6.1 Iteración 1: Primeros pasos con Kinect En esta sección se expone cómo se ha llevado a cabo la primera toma de contacto con Kinect. El principal objetivo de esta primera etapa es familiarizarse con los principales conceptos del dispositivo y su manera de trabajar, así como las peculiaridades más llamativas del mismo que se deben de tener en cuenta a la hora de trabajar. De esta forma, a lo largo de la presente sección se irán exponiendo ejemplos sencillos que permitirán obtener los conocimientos básicos sobre el dispositivo y las bases a tener en cuenta para el desarrollo en las siguientes etapas. Para ello, se ha empleado “SimpleOpenNI”1 como herramienta y [Bor12] como material de referencia de donde se ha extraído la base para los ejemplos. SimpleOpenNI es un wrapper basado en el framework O PEN NI y el middleware NiTE (véase § 4.1.8.2) que permite desarrollar aplicaciones para Processing2 (véase § 5.2.1). Aunque este wrapper no implementa todas las funcionalidades ofrecidas por O PEN NI y NiTE, como primera toma de contacto con Kinect resulta muy interesante ya que se trata de una herramienta relativamente sencilla de utilizar y proporciona un nivel extra de abstracción a las herramientas que serán empleadas en posteriores etapas del proyecto. De esta forma, SimpleOpenNI se convierte en el compañero perfecto para realizar la primera toma de contacto con Kinect y lo que es mucho más importante, ir familiarizándose con las peculiaridades de O PEN NI. No obstante, y a pesar de su sencillez, Processing junto con SimpleOpenNI supone una herramienta muy potente que ha sido utilizada en una gran cantidad de proyectos. Uno de 1 2 https://code.google.com/p/simple-openni/ http://www.processing.org/ 84 los más interesantes es “MAY THE FORCE BE WITH YOU”, que permite mover aguas virtuales proyectadas en una pared (ver Figura 6.1). Figura 6.1: Proyecto “MAY THE FORCE BE WITH YOU” de TeoPatk [wbT14b]. 6.1.1 Primer programa con Kinect Este primer ejemplo es muy simple ya que únicamente consiste en acceder a la Kinect, leer los datos proporcionados por la cámara de profundidad y RGB para posteriormente mostrarlos por pantalla. A partir de este ejemplo base se irán añadiendo pequeñas modificaciones que permitirán ir explorando nuevos conceptos. Aunque el código empleado para la implementación de los diferentes ejemplos de esta sección se encontrarán en un Anexo (véase § A), para mostrar la simplicidad que ofrece SimpleOpenNI, en este primer ejemplo se explicará brevemente los conceptos más básicos sobre cómo funciona (ver Listado 6.1). En la línea 2 se declara un objeto “SimpleOpenNI” con el nombre de Kinect. Este objeto permite acceder a todos los datos proporcionados por Kinect, como la cámara de profundidad o la cámara RGB. El método “setup()” se encarga de configurar e inicializar los diferentes parámetros de la aplicación: Linea 6: Se establece el tamaño de la aplicación. Como se va a trabajar con una resolución de 640 x 480 píxeles en ambas cámaras y se van a mostrar las imágenes capturadas por ambas, es necesario multiplicar el ancho por 2. Linea 7: Se inicializa el objeto “kinect” anteriormente declarado. Lineas 9 y 10: Indican a la aplicación que se quiere acceder a las imágenes de profundidad y RGB respectivamente. Por otra parte, el método “draw()” que funciona a modo de bucle se encarga de ir mostrando por pantalla los datos provenientes de ambas cámaras. Para ello, en la línea 15 se 85 1 2 import SimpleOpenNI .∗; SimpleOpenNI kinect ; 4 5 6 7 void setup () { size (640∗2 , 480) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; kinect . enableRGB () ; 9 10 11 } 13 14 15 void draw () { kinect . update () ; 17 18 19 image ( kinect . depthImage () , 0 , 0) ; image ( kinect . rgbImage () , 640 , 0) ; } Listado 6.1: «Ejemplo 1» versión 1 invoca al método “update()” de la clase SimpleOpenNI, el cual se encarga de actualizar los datos que han sido indicados anteriormente (lineas 9 y 10). Por último, se indica a la aplicación (17 y 18) la posición en la que se quiere ubicar las imágenes capturadas por Kinect y que son recuperadas a través de los métodos “depthImage()” y “rgbImage()” de la clase SimpleOpenNI. En la Figura 6.2 se muestra el resultado obtenido de ejecutar la aplicación, donde la imagen de la izquierda se corresponde con los datos capturados por la cámara de profundidad y la imagen derecha con la cámara RGB. En este punto es necesario destacar que la imagen de profundidad emplea una escala de grises donde la tonalidad representa la longitud a la que se encuentra la superficie respecto la Kinect. No obstante, se aprecian algunos aspectos bastante interesantes que serán desarrollados detalladamente en las siguientes subsecciones. 6.1.1.1. La reflexión En primer lugar, a pesar de que el espejo se encuentra a la misma distancia que la persona que lo sostiene, este presenta un color bastante más oscuro. Esto se debe a que la reflexión provocada por el espejo está causando distorsión en los datos recogidos por la cámara de profundidad. Como se presentó en la sección acerca del funcionamiento de Kinect (véase § 4.1.6), este dispositivo posee un emisor de infrarrojos que emite una nube de puntos. Posteriormente, estos puntos rebotan con las superficies que se encuentran a su paso, lo cual es recogido por el sensor de infrarrojos para crear un mapa de profundidad. Sin embargo, en el caso del espejo, los puntos recogidos realizan un viaje mucho más largo, ya que cuando llegan al espejo, estos son rebotados hacía la pared de enfrente, dando como resultado una distancia mucho más larga (lo cual se traduce en el ejemplo una tonalidad más oscura). 86 Figura 6.2: Captura del primer ejemplo con Processing. No obstante, esto no tiene por qué ser siempre una desventaja. Un ejemplo de ello es el trabajo realizado por el investigador Kyle McDonald, en el cual colocando una serie de espejos similares a los encontrados en los probadores de una tienda de ropa, es capaz de representar escenas en 360 grados sin necesidad de mover el dispositivo en ningún momento (ver Figura 6.3). Figura 6.3: Scanner 3D con Kinect por Kyle McDonald [Bor12]. 6.1.1.2. La oclusión Otro concepto interesante extraído de este primer ejemplo es el de la oclusión y las sombras. Como se puede apreciar en la captura obtenida del ejemplo, la pared que se encuentra situada frente a la Kinect se encuentra totalmente paralela al dispositivo. No obstante, si se comparan las diferentes tonalidades que va tomando la pared en la imagen de profundidad se puede apreciar que, aunque deberían ser iguales ya que se encuentran a la misma distancia del dispositivo, la tonalidad no es uniforme. Este fenómeno se debe a que el patrón de puntos emitido por el dispositivo viajan hasta alcanzar un objeto, siendo a continuación reflejados por la superficie del mismo de vuelta al dispositivo para calcular el mapa de profundidad. 87 Sin embargo, ningún punto será alcanzado por los otros objetos que se encuentran detrás y por consiguiente la Kinect no obtendrá ninguna información acerca de la ubicación de estos, provocando de esta forma sombras negras en la imagen. 6.1.1.3. Desalineamiento entre cámaras Si se observa detenidamente las imágenes capturadas por ambas cámaras, se puede apreciar que, a pesar de que corresponden al mismo instante de tiempo, ambos frames no son exactamente iguales. Este hecho se aprecia claramente si se compara la posición de la cabeza de la persona que aparece en escena en ambas imágenes: Mientras que en la imagen RGB la cabeza ha sido capturada en su totalidad, en la imagen de profundidad tan sólo se ha capturado parcialmente. Como ya se explicó en la sección de características técnicas de Kinect (véase § 4.1.4), el dispositivo captura las imágenes RGB y de profundidad desde cámaras diferentes. Estas cámaras se encuentran separadas la una de la otra en la parte frontal del dispositivo por unos pocos centímetros. De este modo, al encontrarse en posiciones diferentes, los puntos de vista captados por ambas serán forzosamente distintos. 6.1.2 Apreciaciones a nivel de píxel El ejemplo que se expone en esta subsección tiene como objetivo obtener la nociones básicas sobre los valores recuperados por las cámaras y el comportamiento que van adoptando los píxeles en cada momento. Para ello, se ha implementado un ejemplo muy sencillo (ver Listado A.1) que permite obtener, pinchando con el ratón en el área deseada, los valores numéricos que toman en cada momento los diferentes píxeles capturados por las cámaras. A continuación se muestra una captura (ver Figura 6.4) obtenida con este ejemplo y que servirá como base para las explicaciones dadas a continuación. Figura 6.4: Captura del segundo ejemplo con Processing. 88 6.1.2.1. Píxeles RGB Como ya se comentó brevemente en la sección acerca del funcionamiento de la cámara RGB de Kinect (véase § 4.1.6.1), cada píxel de una imagen RGB se caracteriza por tres componentes que representan los valores de los colores rojo (R, red), verde (G, green) y azul (B, blue). Además, cada uno de estos componentes representan, a su vez, un valor decimal comprendido entre 0 y 255 (correspondiendo a un byte), es decir, la cantidad de rojo, verde y azul que hay en ese punto de la imagen. Para quien no esté familiarizado con estos conceptos, es muy posible que en primera instancia se lleve alguna sorpresa con los resultados que pueden ser obtenidos. Un ejemplo de ello puede ser la zona de la imagen que representa el jersey rojo que se encuentra situado encima de la silla. El primer pensamiento que puede venir a la mente es que los píxeles correspondientes a dicho jersey, al ser aparentemente rojo, el valor de la componente “R” debe ser prácticamente 255. No obstante, si se accede a los valores de esos píxeles se aprecia que no es así, obteniendo los siguientes valores: “R: 159.0 G: 1.0 B: 33.0”. A pesar de que para el ojo humano el jersey es completamente rojo, la componente roja de los píxeles correspondientes a esa área es de tan sólo de 158, es decir, poco más de la mitad de su máximo valor. Este hecho muestra la diferencia entre lo que el ojo humano ve e interpreta y los valores que un computador calcula para procesar los datos obtenidos de una cámara digital. De esta manera, es posible afirmar que el cerebro humano interpreta los datos obtenidos por los ojos de una forma “relativa”, centrándose en las variaciones entre las diferentes zonas de la imagen en vez de interpretar sus valores absolutos. Si se exploran otras zonas la imagen, las conclusiones que se pueden obtener son las mismas, como por ejemplo la pared que se encuentra en el fondo de habitación, que es la zona más clara para el ojo humano de toda la imagen. Examinando los valores de los píxeles correspondientes a esta zona, se obtienen resultados muy similares: R: 226.0 G: 219.0 B: 226.0. Esta vez se observa que las tres componentes tienen valores muy similares entre ellas y que además se encuentran muy próximas a los valores que debería tener un píxel completamente blanco (R: 255.0 G: 255.0 B: 255.0). De este modo, las conclusiones que se pueden extraer de esta primera parte del ejemplo son las siguientes: El color representado por un píxel está basado en la diferencia entre los valores que toman su tres componentes. Los píxeles que tienen valores muy próximos en sus tres componentes representan un color blanco o alguna tonalidad de gris. Mientras que los valores relativos de los componentes de un píxel son los que determinan el color percibido por el ojo humano, es la suma de las tres componentes quién determina el nivel de claridad que presentará el píxel. 89 Teniendo claras estas conclusiones, se pone en evidencia un gran problema: Distinguir que píxeles de la imagen pertenecen a cada objeto o persona que aparecen en la escena, una de las tareas de visión por computador que se abordan en este proyecto. En el caso del jersey que se exponía anteriormente, en principio puede ser una tarea relativamente sencilla ya que una posible aproximación podría ser considerar que los píxeles con tonalidades rojas que se encuentren en este área pertenecen al jersey. No obstante, antes se ha puesto en evidencia que los valores de las componentes de un píxel pueden variar drásticamente pudiendo llevar a equívoco. A continuación se exponen dos escenarios que podrían comprometer la validez de esta solución: Escenario 1: Imagine que delante de este jersey rojo se coloca, ocultando parte del mismo, una persona vestida con una prenda del mismo color. En este caso, una imagen RGB tan sólo proporciona información acerca del color de cada píxel de la imagen, y por lo tanto, una aproximación como la expuesta anteriormente establecería que tanto el jersey cómo la prenda roja de la persona son el mismo objeto. Escenario 2: Imagine que parte del jersey, debido a las sombras producidas por algún tipo de luz, tiene zonas muy oscuras próximas al negro. La imagen RGB capturada presentará el jersey con píxeles que varían drásticamente entre unas zonas y otras en función de la luz que esté recibiendo. De este modo, con una aproximación como la expuesta anteriormente el resultado obtenido será que sólo reconoce ciertas partes del jersey. Aunque este tipo de problemas han sido, en parte, solucionados mediante diversas técnicas de visión por computador, una solución perfecta empleando tan sólo cámaras RGB aún se encuentra lejos. En gran parte, esto se debe a que este tipo de cámaras sólo capturan el color de las diferentes partes de la escena sin proporcionar ningún tipo de información sobre la ubicación y distancia a la que se encuentran respecto la cámara 6.1.2.2. Píxeles de profundidad La presente subsección tiene como objetivo analizar los resultados obtenidos por la cámara de profundidad de Kinect y cómo esta información puede resolver de una manera relativamente sencilla los problemas expuestos en la subsección anterior. Para ello, se ha hecho uso del mismo ejemplo que se ha empleado para la anterior subsección. En este caso, al pinchar sobre el jersey rojo que se encuentra colocado sobre la silla, se obtiene un resultado muy diferente: “R: 175.0 G: 175.0 B: 175.0”. A diferencia de lo que ocurría en el caso de la imagen RGB, los valores de los componentes de la imagen de profundidad son idénticos. Si se tiene presente lo expuesto anteriormente, este hecho tiene sentido ya que una imagen de profundidad está representada en escala de grises y por tanto las componentes de cada píxel de la imagen serán siempre iguales variando tan sólo en el brillo, es decir, la distancia entre el blanco y el negro. 90 Gracias a este tipo de imágenes, es posible obtener información muy valiosa para determinar aspectos muy interesantes que resuelven algunos de los problemas encontrados con una cámara RGB. Por ejemplo, a pesar de que el respaldo y el asiento de la silla que aparece en la imagen (ver Figura 6.4) son del mismo color (marrón en este caso), los valores de los píxeles obtenidos en cada parte son muy diferentes: “R: 200.0 G: 200.0 B: 200.0” para el respaldo y “R:251.0 G: 251.0 B: 251.0” para el asiento. Por el contrario, si repetimos el mismo proceso pero con la imagen RGB, los valores obtenidos en este caso son prácticamente idénticos. Esto se debe a que la imagen RGB devuelve el valor del color que toma cada objeto en la imagen, y como en este caso el color de ambas zonas son iguales, los valores serán muy similares variando muy levemente debido a diversos factores como puede ser la incidencia de la luz en cada zona. Por el contrario, la información obtenida en la imagen de profundidad debe ser interpretada de manera muy diferente: Cada píxel representa la distancia entre el objeto que representa y la cámara. De esta forma, el valor de cada píxel de la imagen tomará valores más altos (es decir, colores más claros) en las zonas más próximas a la cámara y valores más bajos (es decir, colores más oscuros) en las zonas más lejanas a la cámara. Por lo tanto, al contrario de lo que ocurre con la imagen RGB que tan sólo proporcionaba información acerca del color de cada parte de la escena, la imagen de profundidad obtiene datos precisos que permiten determinar que el asiento y el respaldo están físicamente separados. Por consiguiente, examinando la imagen de profundidad, es posible determinar, a grosso modo, que los píxeles de la silla que se encuentren en un rango en torno a 200 pertenecen al respaldo y aquellos que se encuentren próximos a 251 pertenecen al asiento. Retomando los escenarios hipotéticos que se presentaban en la subsección anterior (véase § 6.1.2.1), se aprecia que complementando la información obtenida por la camára RGB con la imagen de profundidad es posible solucionar el problema de identificar a que píxeles corresponde cada objeto de la escena: Escenario 1: Es posible determinar que aquellos píxeles de color rojo (con la información obtenida por la cámara RGB) y que posean valores similares en los píxeles de la imagen de profundidad pertenecen al jersey. De esta forma, se puede distinguir entre aquellos píxeles rojos que pertenecen a la prenda de la persona y los que pertenecen al jersey, ya que van a presentar diferentes valores en los píxeles de la imagen de profundidad, es decir, se encuentran a diferente distancia de la cámara. Escenario 2: En esta situación, el ruido introducido en la imagen por la sombras producidas por la luz se puede eliminar gracias a la imagen de profundidad ya que este tipo de cámaras no se ven afectadas por la iluminación presente en la escena. La conclusión más importante que se ha obtenido tras este pequeño ejemplo deja algo muy claro, y es que combinando la información obtenida a través de una cámara de profun91 didad y una cámara RGB es posible obtener resultados mucho más precisos y de forma más eficiente. 6.1.3 Conversión a distancias reales En la subsección anterior (véase § 6.1.2) se presentaba un ejemplo con el cual se intentaba aprender los conceptos más básicos para ser capaces de entender la información proporcionada por Kinect. Uno de los aspectos más interesantes que se presentaban era el hecho de que a través de una imagen de profundidad es posible extraer información acerca de la distancia a la que se encontraba un objeto o persona en la escena. Para ello, se interpretaba el valor de los píxeles: Aquellos píxeles que tenían mayor brillo (valores más altos) se encontraban más cercanos que aquellos con menor brillo (valores más bajos). No obstante, para el desarrollo de aplicaciones más complejas dónde es necesario obtener información más precisa esta información no es suficiente. Como se comentaba en la subsección anterior, los valores que tomaban las diferentes componentes de un píxel pueden oscilar entre 0 y 255. Teniendo en cuenta esto y que el rango de detección de la cámara de profundidad oscila entre 0.5 metros y 7.5 metros, es posible llevar a cabo una aproximación para obtener la distancia real entre un objeto y la cámara. De esta forma, en una primera aproximación se podrían establecer los siguientes parámetros: Aquellos píxeles de la imagen de profundidad que tengan un valor de 0 se encuentran aproximadamente a una distancia de 7.5 metros o más. Aquellos píxeles de la imagen de profundidad que tengan un valor de 255 se encuentran aproximadamente a una distancia de 0.5 metros o menos. Aquellos píxeles de la imagen de profundidad que tengan un valor entre 255 y 0 se encuentran aproximadamente a una distancia comprendida entre 0.5 y 7.5 metros. No obstante, aún es posible hacer un poco más precisa esta primera aproximación. Para ello, simplemente es necesario realizar algunos cálculos bastante simples: Para obtener la distancia aproximada de un píxel con un valor X, donde X está comprendido entre 0 y 255 (0 <X <255), es necesario llevar a cabo lo siguientes pasos: Calcular el valor relativo de X: Este paso consiste tan solo en realizar una simple regla de 3 (ver Ecuación 6.1). V alor relativo de X = X ∗ 100 255 (6.1) Calcular el valor absoluto de la distancia: Una vez obtenido el valor relativo, tan solo es necesario calcular el valor del intervalo entre 0.5 y 7.5 que le corresponde. Realizando estos cálculos, es posible determinar la distancia en metros a la que se encuentra un objeto o persona en la escena respecto a la Kinect a partir del píxel correspondiente de 92 la imagen de profundidad. Aunque en teoría estos cálculos son correctos, si se realiza alguna prueba real se observará que no es así y que la distancia calculada es incorrecta. Para ello, se toma como ejemplo un píxel con valor 96 de la imagen de profundidad capturada con el ejemplo de la subsección anterior (ver Figura 6.4). Si se aplican los cálculos propuestos, se obtiene que el objeto que corresponde a ese píxel se encuentra a una distancia de la Kinect del 37 % entre 0.5 y 7.5 metros, o lo que lo mismo a una distancia de 4.41 metros aproximadamente. No obstante, si se mide la distancia a la que realmente se encuentra ese píxel no es más de tres metros. El motivo de que el resultado de estos cálculos sea incorrecto es que la relación entre el valor del brillo de un píxel en la imagen de profundidad y la distancia real que este representa es mucho más compleja que una simple relación lineal. Como se ha mostrado antes, los píxeles que representan colores de la escala de grises tienen valores que van desde el 0 hasta 250, mientras que la distancia real cubierta por la Kinect se encuentra entre 0.5 y 7.5 metros. Sin embargo, la lecturas obtenidas por una Kinect puede llegar a alcanzar un precisión casi milimétrica que varia entre 0 y 8000 milímetros aproximadamente. Es por este motivo que los píxeles que componen una imagen de profundidad necesiten más de ocho bits para representar la distancia real entre la cámara y el objeto como se venía haciendo hasta este momento. Para obtener una mayor precisión en el calculo de la distancia, es necesario acceder a los datos de profundidad de Kinect de una manera que ofrezca una mayor resolución ya que es capaz de capturar información de profundidad a una resolución de 11 bits por píxel. De este modo, los píxeles capturados por el dispositivo tendrán valores que están comprendidos entre 0 y 2047, que como se puede apreciar a simple vista, es un rango mucho más amplio que el que se estaba empleando hasta ahora (entre 0 y 255). La solución más directa que a primera vista puede surgir es aumentar el tamaño de cada píxel. No obstante, representar las imágenes por pantalla a una mayor resolución por píxel sería totalmente ineficiente por diversos motivos, como por ejemplo el hecho de que el ojo humano no es capaz de apreciar lo suficiente este aumento de la resolución o que provocaría un aumento sustancial del consumo de memoria. Por ello, en el siguiente ejemplo se plantea la solución más eficiente para el objetivo que se persigue en la presente subsección: Experimentar con la cámara de profundidad y tener la posibilidad de comprobar hasta que nivel de precisión es realmente capaz de proporcionar Kinect. Como ser puede ver en el Listado A.2, la solución propuesta continua representando las imágenes de profundidad con píxeles de 8 bits. No obstante, se ha incorporado una modificación muy importante con el objetivo de proporcionar los resultados más precisos que es posible de obtener con Kinect. Para conseguirlo, ya no se accede directamente al valor del píxel de la imagen de profundidad, sino al mapa de profundidad proporcionado por la Kinect. No obstante, se introduce un nuevo concepto que debe tenerse en cuenta: Mientras 93 que la información proporcionada por las imágenes de profundidad están almacenadas en forma de matriz bidimensional, la información proporcionada por el mapa de profundidad es devuelta como una matriz unidimensional. Por este motivo es necesario idear una estrategia que permita establecer la correspondencia directa entre un píxel concreto en la imagen y su correspondiente píxel en la matriz de profundidad. Este concepto es realmente sencillo de entender, pero que sin embargo es crucial para trabajar con las herramientas proporcionadas por O PEN NI y, por consiguiente, con SimpleOpenNI. Como se puede apreciar en la Figura 6.5, establecer una estrategia que permita calcular el píxel correspondiente entre una imagen y una matriz unidimensional resulta ser casi directo. Para este caso concreto, las imágenes tienen una resolución de 640 x 480 píxeles, o lo que es lo mismo, una matriz que está constituida por 640 filas y 480 columnas. Por lo tanto, para conocer la posición en el mapa de profundidad de un píxel que tiene un valor en la imagen de X para el eje x y un valor de Y para el eje y, tan solo es necesario aplicar la ecuación 6.2. Figura 6.5: Comparación entre los píxeles en una matriz bidimensional y una unidimensional [Bor12]. P ixel mapa de prof undidad = X + (Y ∗ 640) (6.2) Otra modificación menos importante, pero también muy interesante que se ha añadido a este ejemplo es la opción de mostrar la distancia en metros y milímetros del píxel pulsado con el ratón en vez de los valores de sus correspondientes componentes como se hacía hasta ahora. Por ejemplo, tomando como referencia la Figura 6.6, se han obtenido resultados increíblemente precisos (ver cuadro 6.1) y mucho más exactos que los que eran obtenidos en los anteriores ejemplos en los que se empleaba un rango de tan solo 255 unidades. 6.1.4 Trabajando en tres dimensiones La información proporcionada por Kinect acerca de la profundidad de los diferentes puntos pertenecientes a una escena ha sido tratada, hasta ahora, como simples metadatos de una imagen en dos dimensiones; sin embargo, hay otra manera en la que esta información de profundidad puede ser procesada. En vez de tratar los datos provenientes de Kinect como 94 Área pulsada Distancia Respaldo de la silla Asiento de la silla Pared del fondo Estantería 1539 milímetros 1039 milímetros 2777 milímetros 2478 milímetros Cuadro 6.1: Resultados del tercer ejemplo con Processing. Figura 6.6: Captura del tercer ejemplo con Processing. una imagen de profundidad bidimensional, es posible pensar que son algo más que la distancia entre un punto en el espacio y la cámara: Un conjunto de puntos en un espacio en tres dimensiones. Si se profundiza en este concepto, la información de profundidad pasaría de ser unos simples metadatos que permiten determinar la distancia de cada punto a ser un conjunto de puntos que proporciona información acerca de la ubicación exacta de cualquier objeto o persona en un espacio tridimensional, es decir, como el mundo real. De esta forma, en vez de crear las típicas imágenes en dos dimensiones, es posible simular modelos tridimensionales de las escenas donde el punto de vista de la cámara puede cambiar de perspectiva sin necesidad de variar la posición de la cámara en ningún momento. Este nuevo concepto ofrece posibilidades muy interesantes ya que, gracias a esta información tridimensional capturada por Kinect, es posible presentar al usuario una escena desde cualquier punto de vista donde puede navegar a través de una habitación sin necesidad de que nada ni nadie se mueva de su sitio. Por otro lado, también es posible desarrollar aplicaciones más avanzadas donde se interactúa con el usuario mediante objetos virtuales representados en tres dimensiones ubicados en una posición concreta dentro de la escena. 95 6.1.4.1. Nube de puntos Como se ha mencionado en los ejemplos anteriores, en Processing el origen del eje de coordenadas se encuentra situado en la esquina superior izquierda del sketch (así se denominan las aplicaciones en Processing). De esta forma, para ser capaces de entender cómo funciona una nube de puntos en Processing es importante conocer que cuando los valores de “x” aumentan, la posición se desplaza hacia la derecha hasta alcanzar el ancho máximo del sketch y que de forma análoga, cuando los valores de ‘‘y” aumentan la posición se desplaza hacía abajo hasta alcanzar la altura del sketch. En la Figura 6.7 se aprecia como los valores de “x” al aumentar su valor se desplazan hacía la derecha del sketch hasta alcanzar cómo máximo el valor 100 y al aumentar los valores de “y” se desplaza hacía abajo del sketch hasta alcanzar cómo máximo el valor 100. Tener claro este concepto será muy importante ya que para trabajar con nubes de puntos en Processing será necesario manipular constantemente el sistema de referencia de coordenadas. Figura 6.7: Origen de coordenadas bidimensional en Processing [web14v]. No obstante, al trabajar con tres dimensiones, entra en juego otra nuevo eje de coordenadas: El eje “z”. Este eje “z” tiene una dirección perpendicular a la pantalla por lo que cuando los valores de “z” aumentan la posición se desplaza hacía fuera de la pantalla (de manera figurada) y cuando disminuyen la posición de desplaza hacía el interior de la pantalla. Por lo tanto, a mayores valor de “z” la imagen se verá más cercana y por el contrario, a menores valores de “z” más pequeña. En la Figura 6.8 se observa el sistema de coordenadas tridimensional resultante. En la subsección anterior se explicaba como trabajar con los valores de profundidad proporcionados por SimpleOpenNI. Estos valores se representaban como una simple matriz unidimensional de enteros donde era necesario traducir los valores “x” e “y” de la pantalla. Sin embargo, además de estos valores de profundidad, la librería puede proporcionar los valores capturados por Kinect como un conjunto de puntos tridimensionales mediante una matriz de vectores. A su vez, cada uno de estos vectores estará compuesto por los valores correspondientes a su posición “x”, “y” y ‘‘z” en el espacio. 96 Figura 6.8: Origen de coordenadas tridimensional en Processing [web14v]. En el Listado A.3 se presenta el código necesario para implementar una nube de puntos de manera estática, es decir, desde un punto de vista fijo. No obstante, es importante destacar algunos conceptos introducidos en este nuevo ejemplo: Cambio del origen de coordenadas: Con este cambio se pretende mover el origen de coordenadas al centro del sketch de modo que la nube de puntos quede centrada en todo momento. Además, también se ha manipulado el eje “z” para que la nube de puntos esté más alejada y de esta forma no quede en ningún momento por delante de la vista. Cambio de sentido del eje “y”: Con el objetivo de ajustar correctamente la información proporcionada por Kinect y la forma en que Processing procesa esta información. SimpleOpenNI ofrece una función, depthMapRealWorld(), que permite obtener la posición de todos los puntos capturados por Kinect. Sin embargo, el sistema de coordenadas de O PEN NI (recordar que SimpleOpenNI está basada en O PEN NI) es diferente al manejado por Processing, ya que los valores de “y” aumentan con posiciones más altas en el espacio. Es por este motivo por lo que es necesario rotar 180 grados el sentido original del eje “y” en Processing. En la Figura 6.9 se presenta una captura de la aplicación durante la ejecución. No obstante, es necesario destacar algunos aspectos que pueden llamar la atención de los resultados obtenidos. En primer lugar, se puede apreciar la similitud que mantiene con las imágenes de profundidad tratadas en las subseciones anteriores como es que sigue tratándose de una imagen en blaco y negro o que siguen apareciendo sombras negras en aquellos zonas donde Kinect no ha capturado ninguna información. El motivo por el cual siguen apareciendo estas sombras negras es que, a pesar de que Kinect captura la información de cientos de puntos, el espacio es una variable continua y por lo tanto infinita. De este modo, el dispositivo tan sólo es capaz de capturar una ínfima parte de este. Por otro lado, sin embargo, se pueden apreciar algunas diferencias interesantes en el resultado. En primer lugar, se produce un aumento considerable de la carga necesaria para ejecutar 97 Figura 6.9: Captura del primer ejemplo de “Nube de puntos”. la aplicación que es debida a la gran cantidad de información que debe ser recogida, procesada y representada por cada frame capturado. En segundo lugar, llama la atención como algunos artículos del mobiliario de la habitación apenas se aprecian, como es por ejemplo el caso de la estantería que está situada al fondo (ver Figura 6.4). Esto se debe principalmente a que la gran cantidad de puntos que se están representando por pantalla en cada frame hace que estos se superpongan y por lo tanto se pierda una gran cantidad de detalle pareciendo un cuerpo sólido. Una posible solución a este problema es representar sólo parte de los puntos que han sido recogidos (ver Figura 6.10). Figura 6.10: Captura del primer ejemplo de “Nube de puntos” donde sólo se representa uno de cada diez puntos capturados. Una modificación muy interesante que se le puede aplicar a este primer ejemplo es hacer que el punto de vista vaya cambiando (ver Listado A.4). Para poder ver la nube de puntos 98 generada desde diferentes ángulos es necesario rotar esos puntos manteniéndolos en todo momento en el centro para provocar la ilusión de que el punto de vista está orbitando alrededor de la nube y no es la nube la que se está moviendo. Para lograr este efecto, es necesario introducir dos pequeños cambios al ejemplo anterior. El primero consiste en añadir una variable que vaya almacenando el ángulo de de rotación actual que será incrementado en cada frame y que será usado para rotar el origen de coordenadas. Y en segundo lugar, es necesario asegurar que esta rotación se está produciendo en todo momento con la nube de puntos en el centro del sistema de coordenadas en vez de en uno de los lados. Si esto no se hace así, cuando se esté produciendo la rotación, la nube de puntos se estará moviendo alrededor del punto de vista y por tanto en ciertos momentos la nube de puntos desaparecerá ya que se encuentra tras el punto de vista. En la Figura 6.11 se muestra una captura mediante la aplicación obtenida una vez aplicados estos cambios. Figura 6.11: Captura del primer ejemplo de “Nube de puntos” desde otro punto de vista. Como se puede apreciar, el resultado obtenido es increíble ya que sin mover la cámara en ningún momento se ha conseguido capturar y representar el perfil de la persona que se encuentra de frente a la cámara. Evidentemente hay multitud de zonas del escenario que aparecen en negro. Esto se debe, como ya se ha explicado antes, a que para esa zona no hay ninguna información, lo cual tiene mucho sentido si se considera, por ejemplo, que la parte trasera del respaldo de la silla se encuentra en todo momento oculto a la cámara y por tanto ningún infrarrojo puede incidir sobre su superficie. No obstante, en ninguno de estos ejemplos se ha explotado el potencial que puede proporcionar la combinación entre la cámara de profundidad y la cámara RGB (ver Listado A.5). Hasta este momento las nubes de puntos representadas se encontraban en blanco y negro 99 debido a que cada uno de los puntos capturados era representado como un punto de color blanco sobre un fondo negro. La idea necesaria para dotar a estos puntos con el color correspondiente de la escena simplemente consiste en acceder, para cada punto de la nube, a su píxel correspondiente de imagen RGB obtenida. Sin embargo, a pesar de que no hay nada que impida llevar a cabo la idea de combinar la información obtenida por ambas cámaras, anteriormente se explicaba (véase § 6.1.1.3) como el punto de vista de ambas cámaras no es exactamente el mismo, ya que la posición de ambas es diferente. Por este motivo es necesario llevar a cabo un alineamiento de los resultados obtenidos por ambas cámaras. Aunque el concepto es muy simple ya que tan solo sería necesario mover la referencia de la matriz obtenida en proporción a la distancia que separa las cámaras, SimpleOpenNI ofrece una función que realiza este proceso directamente de modo que la posición “x” e “y” de la matriz de profundidad y de color corresponden al mismo punto en el espacio. En la Figura 6.12 se muestra una captura mediante la aplicación obtenida una vez aplicado esta modificación donde la persona que aparece en la imagen se encuentra sentada justamente delante de la cámara. En esta ocasión es mucho más latente los pequeños agujeros negros producidos por falta de información de profundidad en determinados puntos, como por ejemplo la sombra detrás de la persona o los numerosos puntos negros en la pared. Figura 6.12: Captura del primer ejemplo de “Nube de puntos” a color. Aunque en los ejemplos se ha mostrado únicamente el concepto de cambiar el punto de vista de la cámara alrededor de la nube de puntos, esta no es la única posibilidad. También es posible realizar aplicaciones interactivas que permitan acercarse a la nube de puntos, rotar o simplemente provocar alguna acción en la aplicación. En la siguiente subsección se mostrará como algunos de los conceptos mostrados en esta subsección han sido llevados a la práctica para desarrollar aplicaciones interactivas en las que la posición del usuario establece el comportamiento de la aplicación. 100 6.1.5 Afianzando los conceptos adquiridos En la siguiente subsección se exponen algunas de las aplicaciones más llamativas que se han implementado en el transcurso del proyecto. El principal objetivo de estas aplicaciones de ejemplo no es otro que el de afianzar y poner en práctica algunos de los conceptos más importantes que se han ido recogiendo a lo largo de la presente sección y que serán de gran utilidad para comprender y manejar las siguientes etapas del proyecto. 6.1.5.1. Dibujando con Kinect La aplicación que se presenta en este apartado consiste en dibujar en la pantalla del ordenador mediante Kinect y guardar la imagen obtenida en un fichero. Para hacer esto posible, es necesario hacer un seguimiento del punto que se encuentra a una menor distancia del dispositivo. Para llevar a cabo esta tarea, es necesario ir comprobando uno a uno todos los píxeles del mapa de profundidad obtenido a través de la Kinect para averiguar cuál posee el valor mas pequeño. En el Listado 6.2 se muestra en pseudocódigo la técnica seguida para conseguirlo. Una vez que se conoce el valor y las coordenadas correspondientes del píxel más cercano, simplemente es necesario dibujar una línea que tiene como origen las coordenadas del píxel más cercano del frame anterior y como final las coordenadas del píxel más cercano del frame actual. Obtener mapa de profundidad de Kinect valo r_mas _cerca no = 8000 por cada fila ‘‘y ’ ’ en la imagen de profundidad por cada pixel ‘‘x ’ ’ de la fila i = x + y ∗ ancho de la imagen valorActual = mapaProfundidad [ i ] si valorActual > 0 y valorActual < v alor_ mas_ce rcano val or_mas _cerca no = valorActual x_mas_cercano = x y_mas_cercano = y dibujar_linea ( anterior_x , anterior_y , x_mas_cercano , y_mas_cercano ) anterior_x = x_mas_cercano anterior_y = y_mas_cercano Listado 6.2: «Dibujando con Kinect» No obstante, siguiendo la estrategia propuesta en esta primera versión, surge un pequeño inconveniente que dificulta la utilización de la aplicación: El efecto espejo. El efecto espejo hace que cuando el usuario mueve la mano hacia su derecha, el lapicero virtual dibuje la línea hacia la izquierda. Este problema se debe simplemente a que la Kinect se encuentra 101 frente al usuario y, por lo tanto, tienen los puntos de vista invertidos. La solución a este contratiempo es bastante sencilla, ya que tan solo es necesario invertir el punto de vista con el que la Kinect captura la imagen. De este modo, simplemente se debe invertir el orden de los puntos de profundidad en el eje “x”. Otro inconveniente que aparece con este primer planteamiento es que mientras que el usuario está dibujando se producen saltos entre cada frame haciendo que sea muy difícil controlar el lapicero para conseguir el resultado deseado. La solución que se ha llevado a cabo para solucionar este problema consiste en realizar una interpolación entre los puntos obtenidos en el frame anterior y los obtenidos en el frame actual. La interpolación es un proceso que permite rellenar el espacio perdido entre dos puntos conocidos, es decir, en vez de saltar directamente al siguiente punto, se orienta la línea con una dirección consistente. De esta manera, las trazas del lapicero virtual serán mucho más suaves, precisas y fáciles de controlar. En el Listado A.6 se encuentra el código resultante de la aplicación una vez aplicados las correcciones que se acaban de exponer y en la Figura 6.13 una captura obtenida a través de la aplicación. Figura 6.13: Captura de la aplicación “Dibujando con Kinect”. 6.1.5.2. Álbum de fotos En las siguientes líneas se expone como desarrollar una aplicación que lleve un poco más lejos los conceptos obtenidos a lo largo de la presente sección y que fueron ya puestos en práctica en el ejemplo “Dibujando con Kinect” mediante el seguimiento del punto más cercano. La aplicación que se propone pretende capturar, a grosso modo, la esencia de las interfaces futuristas mostradas en la película Minority Report de las que ya se habló brevemente en el capítulo de antecedentes de Kinect (véase § 4.1.2.1). 102 Básicamente, la aplicación “Álbum de fotos” permite controlar la posición de tres imágenes a través de la pantalla mediante el movimiento de la mano. Además, también ofrece la posibilidad de ampliar o reducir su tamaño acercando o alejando la mano respectivamente. No obstante, para lograr este comportamiento, los fundamentos desde los que se debe partir son básicamente los mismos que los que se emplearon en el ejemplo “Dibujando con Kinect”: Controlar la posición más cercana a la Kinect en cada momento. Una vez logrado esto, simplemente se debe incluir el comportamiento esperado de las diferentes fotografías: Cuando el punto más cercano al dispositivo se mueva a la derecha, izquieda, arriba o abajo entre frame y frame, debe cambiarse la posición de la fotografía aplicando los mismos principios empleados para mover el lapicero virtual en “Dibujando con Kinect”. Cuando la distancia entre el punto más cercano y la Kinect varíe debe realizarse un escalado de la imagen de forma relativa al valor tomado en ese momento por el punto más cercano. Cuando se pulse el botón derecho del ratón, debe cambiarse a la siguiente imagen. Por lo tanto, en este caso es necesario ir almacenando en cada momento la fotografía que se encuentra activa en ese instante y las posiciones anteriores de cada una. En el Listado A.7 se encuentra el código resultante y en la Figura 6.14 una captura obtenida a través de la aplicación. Figura 6.14: Captura de la aplicación “Álbum de fotos”. 6.1.5.3. Batería virtual La aplicación que se presenta en este apartado (Listado A.8 y A.9) tiene como objetivo afianzar los conceptos relacionados con la nube de puntos que se han aprendido en los apartados anteriores (véase § 6.1.4.1). Para ello se ha propuesto la implementación de una batería virtual que permite al usuario simular que está tocando una batería. Esta batería estará 103 compuesta por dos tambores que serán representados como cubos virtuales colocados en la región que se encuentra delante del dispositivo. De esta forma, cuando el usuario entre en contacto con alguno de los cubos se reproducirá el sonido correspondiente a dicho cubo. Una vez entendido cómo funciona las nubes de puntos, es hora de introducir un nuevo concepto para hacer posible la batería virtual, los puntos calientes. Un punto caliente consiste en una zona en el espacio, en este caso el cubo virtual, donde se tiene especial interés en averiguar si hay algún punto contenido en ella o contabilizar cuántos puntos se encuentran en esa zona. De esta forma, un punto caliente es similar a los típicos botones que se utilizan diariamente en las aplicaciones de escritorio donde se detecta cuándo ha sido pulsado por un usuario mediante un ratón cuyo puntero se encuentra situado sobre él. No obstante, a diferencia de estos botones bidimensionales que presentan un estado binario (pulsado o no pulsado), un punto caliente representa un botón tridimensional que puede ser activado por una gran variedad de eventos: Hay algún punto dentro de sus límites, hay más de cien puntos en su interior, etc. De este modo, principalmente es necesario llevar acabo dos tareas. La primera consiste en indicar al usuario cuáles son las zonas del espacio con las que puede interactuar, mientras que la segunda consiste en monitorizar esas zonas para determinar si el el usuario ha interactuado con ellas. Para realizar la primera tan sólo se necesita dibujar en el sketch las aristas de dos cubos en el área donde se quiera ubicar el punto caliente y dotarles de color cuando el usuario introduzca la mano o cualquier objeto dentro de ellos. Para llevar a cabo la segunda será necesario controlar en cada frame si cualquier parte de la nube de puntos está contenida dentro del punto caliente. La manera de contabilizar el numero de puntos de la nube que está contenida en el punto caliente, en este caso el cubo, es necesario comprobar punto a punto si cumplen los siguientes requisitos: Su coordenada x debe ser mayor que la coordenada x más pequeña del cubo y menor que la coordenada x más grande. Su coordenada y debe ser mayor que la coordenada y más pequeña del cubo y menor que la coordenada y más grande. Su coordenada z debe ser mayor que la coordenada z más pequeña del cubo y menor que la coordenada z más grande. Si cualquier punto de la nube cumple estas condiciones, es posible afirmar que se encuentra dentro del cubo. En el caso concreto de Processing, un cubo está definido por un punto origen y el tamaño de su arista. Por lo tanto, para comprobar en Processing si un punto está contenido dentro de el es necesario considerar los requisitos anteriores de la siguiente manera (ver Figura 6.15): Su coordenada x debe ser mayor que la coordenada x del origen del cubo menos la mitad del tamaño de la arista y menor que la coordenada x del origen del cubo más la 104 mitad del tamaño de la arista. Su coordenada y debe ser mayor que la coordenada y del origen del cubo menos la mitad del tamaño de la arista y menor que la coordenada y del origen del cubo más la mitad del tamaño de la arista. Su coordenada z debe ser mayor que la coordenada z del origen del cubo menos la mitad del tamaño de la arista y menor que la coordenada z del origen del cubo más la mitad del tamaño de la arista. Figura 6.15: Distribución de un cubo en Processing [Bor12]. Finalmente, para que el comportamiento de la aplicación sea lo más realista posible, es necesario tener en cuenta otro requisito más para reproducir el sonido aparte del que establece que debe haber algún punto contenido en el cubo. Este requisito indica que, para reproducir un sonido, es necesario que en el frame anterior no debía haber ningún punto en el cubo. De esta manera se asegura que el usuario debe, una vez que a tocado el cubo, levantar la mano para que sea posible volver a tocarlo, tal y como se haría en un tambor de verdad. En la Figura 6.16 se presenta una captura del resultado conseguido al llevar a la práctica todos los conceptos expuestos. 6.2 Iteración 2: Comprendiendo el funcionamiento de O PEN NI Una de las primeras etapas necesarias para el desarrollo de un sistema de reconocimiento de acciones es la implementación de una aplicación que permita capturar la información del entorno a través de un dipositivo hardware, en este caso Kinect. Es por este motivo por el que en la presente sección se pretende proporcionar una visión general acerca de los aspectos más básicos acerca de la plataforma O PEN NI que han sido cruciales para el desarrollo y depuración de esta etapa del proyecto. No hay que olvidar que uno de los aspectos que hace más interesante la utilización de Kinect para el reconocimiento de acciones es la posibilidad de capturar la posición real de las personas y objetos que se encuentran en el entorno a través de su sensor de profundidad, función que será implementada a través del middleware NiTE para O PEN NI. Motivo de más por el que una completa 105 Figura 6.16: Captura de la aplicación “Batería virtual”. y correcta comprensión sobre el funcionamiento de más bajo nivel de O PEN NI es crucial para la constitución de una base sólida sobre la que llevar a cabo las siguientes etapas del proyecto. Además, también se realiza una pequeña introducción acerca de una de las librerías de OpenGL (GLUT3 ) a través de la cual se ha logrado realizar una interfaz de usuario que permita mostrar por pantalla los datos capturados por Kinect así como interactuar con la aplicación. Por último, se muestran los resultados obtenidos de la primera aproximación del módulo que constituirá la captura de datos a través de Kinect mediante de la integración de de O PEN NI y GLUT. 6.2.1 Aspectos básicos sobre la librería Como ya se explicó anteriormente, O PEN NI es una plataforma que proporciona acceso a los sensores de profundidad compatibles con PrimeSense. Además, permite a los desarrolladores de aplicaciones inicializar los sensores y recibir los flujos de datos de profundidad, RGB y vídeo IR del dispositivo. O PEN NI también proporciona una interfaz uniforme a módulos middleware desarrollados por terceros que pueden ser usados para interactuar con estos dispositivos de profundidad. Por lo tanto, las aplicaciones son capaces de utilizar tanto el middleware de terceros, así como los datos de profundidad y de vídeo básicos subyacentes proporcionados directamente por O PEN NI. Tras esta visión general y la introducción proporcionada acerca de la evolución de la arquitectura interna de la plataforma en el capítulo de antecedentes (véase § 4.1.8.2), es el mo3 http://www.opengl.org/resources/libraries/glut/ 106 mento de profundizar un poco más y bajar un nivel más el nivel de abstracción proporcionado hasta el momento. Esto se debe a que más adelante será esencial su completa comprensión para solventar los problemas que irán surgiendo debido a la alta sobrecarga de este tipo de sistemas. Es importante destacar que algunos aspectos resultarán ya familiares. La causa de esto se debe a que la herramienta utilizada en la sección anterior, la librería “SimpleOpenNI” para Processing (véase § 6.1), estaba basada internamente en funciones proporcionadas por O PEN NI. Este hecho será de gran utilidad para comprender más fácilmente como funciona la plataforma. Para proporcionar esta visión de bajo nivel se pretende explicar en qué consiste el funcionamiento de las cuatro clases principales necesarias para obtener los flujos de información obtenidos por el dispositivo: openni::OpenNI openni::Device openni::VideoStream openni::VideoFrameRef Además de estas cuatro clases fundamentales, también se comentarán brevemente otras clases de soporte así como las estructuras que son proporcionadas por la plataforma para el almacenamiento de diferentes tipos específicos de datos. 6.2.1.1. openni::OpenNI La primera de las principales clases de las que está compuesta O PEN NI 2.0 es openNI::OpenNI. Esta clase es fundamental ya que proporciona un punto de entrada estático a la API, además de ser empleada para proporcionar acceso a todos los dispositivos en el sistema. Entre las funcionalidades más importantes que ofrece esta clase, destacan la posibilidad de realizar varios eventos de conexión y desconexión de los dispositivos que se encuentran disponibles en un momento determinado, así como proporcionar funciones que permitan el acceso a todos los flujos de datos que son capturados por el sensor. 6.2.1.1.1. Acceso al dispositivo Para proporcionar el punto de entrada estática a la API, es necesario hacer uso de la función “initialize()” proporcionado por esta clase. Esta función inicializa todos los controladores de los sensores disponibles y explora el sistema para localizar los dispositivos que se encuentran disponibles. Es importante destacar que cualquier aplicación que utiliza O PEN NI debe llamar a esta función antes de realizar cualquier otro uso de la API. Una vez que la función “initialize()” haya sido invocada, será posible crear objetos de la clase “Device” que posteriormente serán empleados para comunicarse con el hardware actual del sensor. La función “enumerateDevices()” de la clase O PEN NI permite averiguar que 107 dispositivos se encuentran conectados al sistema y que se en ese momento están preparados para ser usados. Por último, cuando una aplicación está lista para finalizar, la función “shutdown()” debe ser invocada para apagar todos los controladores y realizar una salida limpia de la ejecución. 6.2.1.1.2. Acceso a los flujos de vídeo La función “waitForAnyStream()” permite implementar un sistema de pulling para el acceso a los diferentes flujos de información proporcionados por el dispositivo. De esta forma, cuando es invocada se bloquea hasta que cualquiera de los flujos de datos de la lista pasada como parámetro tienen nuevos datos disponibles. Esta función es ideal para ser invocada desde un bucle en el que cada vez que nuevos datos son capturados, se desea realizar alguna operación con ellos, ya se mostrarlos por pantalla, procesarlos, etc. 6.2.1.1.3. Acceso a los dispositivos a través de eventos La clase O PEN NI proporciona un framework para el acceso a los dispositivos a través de un marco de ejecución dirigido por eventos. Para ello, O PEN NI define tres tipos de eventos: “onDeviceConnected”: Este evento es generado cada vez que un nuevo dispositivo es conectado y se encuentra disponible a través de la interfaz O PEN NI. “onDeviceDisconnected”: Este evento es generado genera cuando un dispositivo es retirado del sistema. “onDeviceStateChanged”: Este evento es generado cada vez que se cambia alguno los parámetros del dispositivo. Para controlar estos eventos, O PEN NI proporciona una serie de clases “listener” que pueden ser añadidas a través de los siguientes métodos: “addDeviceConnectedListener()”, “addDeviceDisconnectedListener()”, “addDeviceStateChangedListener()”, “removeDeviceConnectedListener()”, “removeDeviceDisconnectedListener()”, “removeDeviceStateChangedListener()”. Los tres eventos descritos anteriormente proporcionan un puntero a un objeto “OpenNI::DeviceInfo” que puede ser utilizado para obtener los detalles y la identificación del dispositivo contemplado por el evento. Además, el evento “onDeviceStateChanged” proporciona un puntero a un objeto “DeviceState” que permite ver cuál es el nuevo estado del dispositivo. 6.2.1.1.4. Información de errores Muchas funciones proporcionadas por la plataforma tienen un tipo de retorno especial: 108 "Status". De esta forma, cada vez que se produce un error, el estado devuelto por la función contendrá un código que puede estar tratado por el código correspondiente o simplemente ser mostrado al usuario. Además, el método “OpenNI::getExtendedError()” devuelve información adicional sobre el error que se ha producido de una manera legible para los humanos. 6.2.1.2. openni::Device Esta clase proporciona una interfaz para controlar un único dispositivo hardware. De esta manera, un objeto “Device” es usado para conectar y configurar un dispositivo y crear los diferentes objetos “Stream” que permitirán recuperar los flujos de información capturados por los sensores. No obstante, antes de que un objeto de la clase “Device” pueda ser conectado a un dispositivo hardware, es necesario que este último se encuentre físicamente conectado al ordenador. También es necesario que la función “openni:initialize()” haya sido previamente invocada para inicializar los drivers correspondientes al dispositivo y marcarlo como disponible a través de la API. A continuación se describen las funciones más importantes que se encuentran disponibles a través de esta clase: Constructor: Esta función no toma argumentos ya que simplemente crea el objeto en la memoria para que otras funciones puedan ser invocadas. Device:open(): Esta función es muy importante ya que es la que realmente conecta el objeto “Device” con el dispositivo hardware. Para ello toma tan solo la URI del dispositivo como argumento, devolviendo un código de estado indicando si la operación ha sido realizada con éxito o qué error se ha producido. No obstante, el uso más simple de esta función es invocarla con la constante “OpenNI::ANY_DEVICE” como URI para que el sistema se conecte a cualquier dispositivo hardware compatible que se encuentre activo en ese momento. Esto puede resultar verdaderamente útil cuando es posible suponer con total seguridad que hay exactamente un dispositivo activo conectado al sistema. En el caso de que haya múltiples dispositivos conectados al sistema, se debe realizar antes una llamada al método “enumerateDevices()” de la clase O PEN NI para obtener una lista de todos los dispositivos que se encuentran conectados y así poder obtener la URI correspondiente al dispositivo deseado para la función “open()” . Device:close(): Esta función permite cerrar correctamente el dispositivo de hardware. de esta forma, tanto el driver como el dispositivo hardware quedarán en un estado conocido para que las aplicaciones futuras no tengan dificultades para conectarse a ellos. Device:isValid(): Esta función permite determinar si existe actualmente un dispositivo activo conectado a este objeto “Device”. 109 Por último, es necesario destacar que también es posible obtener la información básica acerca de un dispositivo y que posteriormente puede ser de gran utilidad como son el nombre, el proveedor, la URI, etc. Para ello, O PEN NI proporciona la clase “OpenNI::DeviceInfo” para contener toda esta información. De esta manera, si se desea obtener el objeto “DeviceInfo” de un dispositivo concreto es necesario llamar a la función “Device:getDeviceInfo()”. 6.2.1.3. openni::VideoStream Esta clase encapsula todos los flujos de datos creados por la clase de “Device” permitiendo al programador solicitar que la captura de determinados flujos de datos comiencen (“VideoStream::start()”), paren (“VideoStream::stop()”) o simplemente indicar su configuración. Una vez que un VideoStream ha sido creado a través de la función “VideoStream::create()”, los datos pueden ser leídos de ella directamente con la función “VideoStream::readFrame”. De esta forma, si hay nuevos datos disponibles, esta función facilitará el acceso al objeto VideoFrameRef más reciente que haya sido generado por el VideoStream. Si no hay ningún nuevo frame listo todavía, la función se bloqueará hasta que un nuevo frame esté disponible. Por último, tan sólo destacar que la clase VideoStream ofrece la posibilidad de recuperar la información capturada por los dispositivos a través de eventos. 6.2.1.4. openni::VideoFrameRef Esta clase tiene el objetivo de encapsular todos los datos relacionados a un solo tipo de frames leídos a través de un VideoStream mediante la función “VideoStream::readFrame()”. De esta forma, mediante la función “VideoFrameRef::getData()” proporciona acceso a la matriz subyacente que contiene los datos del frame, así como los metadatos que son requeridos por el programador para trabajar con dichos datos. Esta metainformación en las venideras etapas del proyecto serán básicas para el procesamiento y categorización de los frames que serán capturados por la aplicación. Algunos de los más destacados son la marca temporal de captura, la resolución, el índice de frame, etc. 6.2.2 GLUT OpenGL Utility Toolkit (GLUT) es una interfaz de programación enlazada con ANSI C y FORTRAN con el objetivo de facilitar el desarrollo de programas basados en OpenGL de manera independiente del sistema operativo. Las funcionalidades más destacadas ofrecidas por esta biblioteca de utilidades son: Múltiples ventanas de renderizado OpenGL. Dispositivos de entrada sofisticados. Rutinas para la generación de objetos. Diversas funciones de gestión de ventanas. 110 Soporte de mapas de bits. Procesamiento de eventos. Rutina “idle” y temporizadores. La biblioteca GLUT original fue escrita por Mark Kilgard, autor de OpenGL Programming for the X Window System [Kil96] y The Cg Tutorial: The Definitive Guide to Programmable Real-Time Graphics [FK03]. Sin embargo, el proyecto inicial de Kilgard ya no ofrece mantenimiento y su licencia no libre no permite la redistribución de versiones modificadas de la biblioteca. Es por este hecho por el que comenzaron a surgir diferentes implementaciones libres de la API implementadas desde cero. La primera fue freeglut4 , con la intención de convertirse en un clon bastante exacto de la original, aunque con un un pequeño número de nuevas funciones para hacer frente a las limitaciones de GLUT que más adelante se comentan. Existe también otra variante de freeglut llamada OpenGLUT 5 , que añade algunas nuevas funcionalidades respecto de la API original. No obstante, no hay que perder de vista que GLUT surgió con el objetivo de simplificar la implementación de programas usando OpenGL como herramienta de renderizado y permitir el desarrollo de código más portable entre diferentes sistema operativos. Es por esta razón por la que el API de GLUT está compuesto de tan solo unas pocas rutinas para mostrar escenas gráficas renderizadas a través de OpenGL. Estas rutinas, a su vez, están lógicamente organizadas en varias sub-APIs de acuerdo a su funcionalidad: Inicialización: Se encarga del procesamiento de la línea de comandos, la inicialización del sistema de ventanas y el estado de creación de la ventana inicial. Procesamiento de eventos: Esta rutina entra en bucle de procesamiento de eventos de GLUT. Además, no retorna nunca y llama continuamente a los “callbacks” de GLUT siempre que es necesario. Gestión de ventanas: Rutinas encargadas de la creación y control de ventanas. Gestión de superposición: Rutinas encargadas de establecer y gestionar la superposición de ventanas. Gestión de menús: Rutinas encargadas de crear y controlar los menús “pop-up”. Registro de devolución de llamadas: Rutinas encargadas de registrar los callbacks que serán llamados por el bucle de procesamiento de eventos GLUT. Gestión del “Colormap”: Estas rutinas permiten la manipulación de los mapas de colores empleados en las ventanas. Recuperación de estado: Estas rutinas permiten a los programas recuperar el estado de GLUT. 4 5 http://freeglut.sourceforge.net/ http://openglut.sourceforge.net/ 111 Renderizado de fuentes: Estas rutinas permiten el renderizado del trazado y mapas de bits de las diferentes fuentes. Renderizado de formas geométricas: Estas rutinas permiten el renderizado de formas geométricas en tres dimensiones incluyendo esferas, conos, icosaedros, etc. Para trabajar con esta herramienta, es necesario estar relacionado con algunos aspectos de la terminología de GLUT. Algunos de los más destacados son los siguientes: “Callback”: Rutina específica que puede ser registrada en GLUT para ser llamada en respuesta de un tipo de evento concreto. También es utilizada para referirse a una rutina “callback” específica para la devolución de una llamada. “Colormap”: Proporciona un mapeo entre los valores de un píxel y los valores de los colores RGB. “Idle”: Estado en el que se notifican los eventos del sistema de ventanas para su procesamiento. Si se existe algún “callback” registrado para el evento correspondiente, será invocado. “Menú pop-up”: Menú que puede ser configurado para que aparezca cuando se presiona un botón específico del ratón en una ventana. “Sistema de ventanas”: Concepto que se refiere al mecanismo y política del sistema y gestión de ventanas. Por ejemplo, en el sistema X Window, tanto el administrador de ventanas y como el servidor X son parte integral de lo que GLUT considera el sistema de ventanas. Como se puede apreciar, GLUT es una herramienta ideal para programas simples en las que las necesidades del programador son muy concretas y de alto nivel. Además, introducirse en la programación con OpenGL utilizando GLUT conlleva normalmente sólo unas pocas líneas de código y hace innecesario el conocimiento de las APIs específicas de cada sistema operativo. No obstante, esta biblioteca multiplataforma se encuentra con algunas limitaciones que dificultan la labor del programador para el desarrollo de tareas específicas. Entre las más destacadas se encuentran: La biblioteca exige a los programadores invocar a la función “glutMainLoop()”, función que nunca finaliza. Es por esto por lo que los programadores se encuentran con serios problemas para integrar GLUT en aplicaciones o bibliotecas en las que es necesario poder tener control sobre su propio ciclo de ejecución. No obstante, existen diferentes aproximaciones para solucionar este inconveniente. Una de las más habituales consiste introducir una nueva función, que suele llamarse “glutCheckLoop()“, que ejecute una sola iteración del ciclo de ejecución de GLUT. Otra posible solución puede ser la de ejecutar GLUT por separado mediante hilos, aunque esto puede ser distinto dependiendo del sistema operativo pudiendo provocar de esta manera problemas 112 de sincronización. El hecho de que la función “glutMainLoop()” nunca termine supone que el programa no sale nunca del ciclo de ejecución. Otra implementaciones basadas en GLUT, como por ejemplo freeglut, soluciona este problema introduciendo una nueva función “glutLeaveMainLoop()” que permite decidir en tiempo de ejecución si salir del bucle principal. La biblioteca termina el proceso cuando se cierra la ventana principal del programa suponiendo un inconveniente en determinadas situaciones en las que este comportamiento puede no ser el deseable. Por eso muchas implementaciones incluyen una función extra llamada “glutWMCloseFunc()”. A pesar de estas limitaciones, durante esta etapa del proyecto se decidió emplear GLUT ya que, además de que la funcionalidad que proporcionaba resultaba completamente suficiente para los objetivos marcados, ofrecía una solución rápida de aprender, relativamente ligera en comparación a otras alternativas y que además permitía obtener un código sencillo y claro. 6.2.3 Primera versión del módulo de captura de imágenes En esta primera aproximación de la solución se pretende desarrollar la base sobre la que se asentará el módulo de captura de imágenes. De este modo, el principal objetivo marcado en esta etapa no será otro que el desarrollo del esqueleto de la aplicación a partir del cual se irán añadiendo de manera iterativa diversas mejoras y funcionalidades a lo largo del proyecto. Por lo tanto, será necesario realizar un pequeño estudio acerca de las posibilidades ofrecidas por las herramientas comentadas en los apartados anteriores y la manera de integrarlas en el módulo para obtener el máximo rendimiento. El primer paso realizado para la consecución de este objetivo es la definición de cuáles serán las funcionalidades deseadas para esta primera versión. Para ello, se han definido los siguientes hitos: Captura del flujo de datos de la cámara RGB. Captura del flujo de datos del sensor de profundidad. Visualización de los flujos de datos capturados por el dispositivo a través de una interfaz de usuario sencilla y minimalista. Integración de comandos de teclado básicos que permitan a través de la interfaz de usuario interactuar con la aplicación: • Cerrar la aplicación. • Seleccionar que flujo de datos se debe mostrar por pantalla. 113 Una vez que los hitos que deben ser alcanzados con esta primera iteración del módulo están definidos, es el momento de realizar el primer diseño de clases. Como se puede apreciar en la Figura 6.17, la solución propuesta está compuesta de dos clases. La clase “Main” es la clase principal y su función no es otra que inicializar todos los aspectos necesarios para comenzar a utilizar el dispositivo y controlar que los resultados obtenidos de esta inicialización son los esperados. En segundo lugar se ha definido la clase “Recorder”, encargada de gestionar todos los aspectos relacionados con el procesado de los flujos obtenidos a través del dispositivo y su posterior renderizado para mostrarlos por pantalla. Figura 6.17: Diagrama de clases del módulo de captura de imágenes (versión 1). Una vez que la solución propuesta para esta primera versión fue implementada, se llevó a cabo una pequeña batería de pruebas para verificar que los resultados son los deseados y corregir aquellos errores no deseados que se puedan producir durante la ejecución como pueden ser desbordamientos de memoria, pérdida de frames, etc. A continuación se muestran algunas capturas de los resultados obtenidos (ver Figura 6.18 y Figura 6.19) 6.3 Iteración 3: Incorporación de NiTE Una vez que se han entendido los principios más importantes acerca del funcionamiento de O PEN NI y GLUT y se tiene la base del módulo de captura de imágenes a partir de la cual 114 Figura 6.18: Módulo de captura de imágenes en modo RGB. Figura 6.19: Módulo de captura de imágenes en modo profundidad. se van a implementar el resto de funcionalidades, es el momento de realizar la primera toma de contacto con NiTE. Es por este motivo por el que en la presente sección se pretende proporcionar una visión general acerca de los aspectos más relevantes que deben de ser tenidos en cuenta a la hora de utilizar la plataforma NiTE. También se desarrollará la forma en que funciona internamente este middleware así como los principales algoritmos de reconocimiento y seguimiento de usuarios que pone a disposición de los desarrolladores. No obstante, será necesario proporcionar también una visión aproximada sobre la forma en la que trabaja NiTE internamente, algo indispensable para solucionar algunos aspectos que deberán de ser mejorados en módulo de captura durante su desarrollo. Por último, se muestra la evolución que ha ido experimentando el módulo a lo largo de las diferentes iteraciones según se iban incorporando nuevas funcionalidades y se corregían los problemas que se iban encontrando. 115 6.3.1 Toma de contacto con NiTE Como ya se comentaba brevemente en la sección de antecedentes (véase § 4.1.8.2), uno de los middleware más importantes y potentes para la plataforma O PEN NI es NiTE. De esta forma, NiTE constituye un de los middlewares más avanzados y robustos del mercado en el campo de visión por computador en 3D. NiTE proporciona a los desarrolladores una API relativamente sencilla poniendo a su alcance potentes algoritmos que permiten el diseño de aplicaciones controladas por las manos y la posición del cuerpo del usuario. Estos algoritmos utilizan la información de profundidad, color e IR recibida por el sensor para realizar tareas como la localización y seguimiento de las manos, análisis de escenas (separando a los usuarios del fondo de la imagen), seguimiento preciso del esqueleto, reconocimiento de gestos, etc. A continuación se desarrollarán los aspectos más básicos e importantes sobre los dos componentes principales de la API, cuyo análisis y entendimiento es crucial para la presente etapa del proyecto: Seguimiento de manos y detección de gestos. Seguimiento del cuerpo. 6.3.1.1. Seguimiento de manos y detección de gestos El seguimiento basado en las manos es la posibilidad que ofrece NiTE para seguir a los usuarios a través de los algoritmos de seguimiento de manos o detección de gestos discretos. Para alcanzar este objetivo, las aplicaciones que empleen cualquiera de estos dos tipos de algoritmos deben seguir las instrucciones y convenciones desarrolladas a continuación. De esta forma, será posible implementar pequeños ejemplos que faciliten el análisis de las posibilidades reales que ofrecen y por lo tanto recopilar suficiente información de primera mano que permita determinar si estas funcionalidades de seguimiento de manos y detección de gestos aportan resultados de valor para el objetivo del proyecto. Para ello, el primer paso es entender el funcionamiento de la API que, debido a la alta encapsulación que presenta, en primera instancia puede resultar verdaderamente complicada. Al igual que ocurría con la API de O PEN NI, el primer paso necesario para empezar a emplear los algoritmos que ofrece NiTE es inicializar la clase “HandTracker” para conectar con el objeto “Device” relacionado con un dispositivo hardware concreto (véase § 6.2.1.2). De esta forma, cada vez que un objeto “Device” crea un nuevo frame de profundidad, la clase HandTracker genera los datos correspondientes a la manos a las que se les está realizando el seguimiento. Toda esta información será devuelta en la clase contenedora “HandTrackerFrameRef” con los siguientes datos: Frame de profundidad. Manos identificadas. 116 Posiciones de las manos. Manos que aparecían en el frame anterior pero que en el actual han desaparecido de la escena. Gestos identificados en el frame actual. En el Listado 6.3 se muestra un fragmento de un pequeño ejemplo de cómo debería realizarse este proceso de detección de gestos. La dinámica a seguir es bastante sencilla, ya que tan solo es necesario indicar al algoritmo qué gestos son los deseados para realizar el seguimiento (líneas 1 y 2), recuperar los gestos detectados (línea 4) y posteriormente realizar las operaciones deseadas para aquellos gestos que hayan sido completados (líneas 5-12). 1 2 handTracker . s t a r t G e s t u r e D e t e c t i o n ( nite :: GESTURE_WAVE ) ; handTracker . s t a r t G e s t u r e D e t e c t i o n ( nite :: GESTURE_CLICK ) ; 4 const nite :: Array < nite :: GestureData >& gestures = handTrackerFrame . getGestures () ; for (int i = 0; i < gestures . getSize () ; ++ i ) { if ( gestures [ i ]. isComplete () ) { nite :: HandId newId ; handTracker . sta rtHand Tracki ng ( gestures [ i ]. ge tCu rr en tP os it io n () , & newId ) ; } } 5 6 7 8 9 10 11 12 Listado 6.3: Detección de poses con NiTE A pesar de que la detección de gestos que ofrece NiTE podría ser una herramienta verdaderamente útil para el posterior reconocimiento de acciones, uno de los principales objetivos del proyecto, tras un análisis exhaustivo se ha concluido que para tal fin presenta serias limitaciones. La más destacada es el hecho de que NiTE sólo tiene definido dos tipos de de gestos: “Click”: Consiste en acercar la mano hacia la cámara y después alegarla de ella. “Wave”: Consiste en mover la mano de un lado a lado, como si se estuviera saludando a la cámara. Una opción que podría haber sido interesante para enriquecer estos algoritmos es añadir los gestos deseados a la API. No obstante, es necesario recordar que la licencia bajo la que este middleware es distribuido lo impide. Por lo tanto, se ha decidido no integrar este tipo de algoritmos proporcionados por NiTE ya que no aportan valor real a la solución perseguida por este proyecto. 117 6.3.1.2. Seguimiento del cuerpo Los algoritmos de obtención de la posición del cuerpo humano a partir de las articulaciones de los usuarios hacen del middleware NiTE un componente de gran valor para el desarrollo del presente proyecto. Además, también proporcionan la capacidad de segmentar a los usuarios, detección del plano del suelo, detección de poses y el seguimiento del esqueleto. El primer paso que debió seguirse para la correcta integración de estos algoritmos en este módulo del proyecto fue analizar y comprender como procesa NiTE el flujo de datos proporcionados por el sensor, que información proporciona y cómo interpretarla y por último identificar las clases y funciones correspondientes a estos algoritmos así como su manera de proceder junto con las limitaciones que presenta. 6.3.1.2.1. Funcionamiento Aunque el funcionamiento interno de NiTE no es de dominio público, realizando un análisis exhaustivo de su forma de trabajar y del API es posible realizar una aproximación de cómo procede internamente para la detección de usuarios. En la Figura 6.20 se puede apreciar que los usuarios pasan por tres estados: Nuevo usuario: Un nuevo usuario ha entrado en la escena pero aún no se ha calibrado su posición. Siguiendo usuario: Tras ser detectado un nuevo usuario, este pasa al estado de usuario seguido dónde se encuentra disponible toda la información relativa a su posición, articulaciones, orientación, etc que se estudiará más adelante. Usuario perdido: Estado al que pasa un usuario que estaba siendo seguido tras haber salido de la escena o debido a la incapacidad de los algoritmos de NiTE de proporcionar información precisa sobre él. Cuando NiTE recibe la señal de realizar el seguimiento de usuarios, aplica internamente sus algoritmos de procesado a cada frame que es capturado por el dispositivo. Una vez que ha realizado los cálculos pertinentes, obtiene una lista de todos los posibles usuarios que hay presentes en la escena. En un segundo paso, NiTE aplica los algoritmos correspondientes para realizar la calibración de la posición de cada usuario detectado en la etapa anterior. Si esta última etapa es realizada con éxito, NiTE será capaz de proporcionar toda la información relativa al usuario. 6.3.1.2.2. Análisis e interpretación de la información proporcionada La correcta realización del análisis e interpretación de la información ofrecida por los algoritmos de NiTE es crucial y potencialmente crítica para una correcta integración de las funcionalidades de seguimiento de usuario en este módulo del proyecto. Por este motivo, 118 Figura 6.20: Funcionamiento del seguimiento de usuarios con NiTE [web14u]. durante el desarrollo del proyecto esta etapa abarcó varias semanas ya que un error de interpretación de los resultados sería arrastrado en las etapas posteriores. En primer lugar, es muy importante tener en cuenta que NiTE trabaja con dos tipos de coordenadas: Coordenadas de profundidad (proyectivas) y coordenadas del mundo real. Este último tipo de coordenadas son medidas en milímetros siguiendo un sistema de coordenadas como el que se muestra en la Figura 6.21. De esta manera, cuando un punto en el espacio se desplaza hacía la izquierda del dispositivo la coordenada x aumentará; según aumente la distancia del punto con respecto el suelo mayor será el valor de y; y por último cuando más alejado se encuentre un punto respecto la Kinect mayor será su componente z. No obstante, NiTE ofrece la posibilidad de convertir un punto entre ambos tipos de coordenadas. Figura 6.21: Sistema de coordenadas de NiTE. NiTE distingue entre los diferentes usuarios que se encuentran mediante un id que le será 119 asignado en el primer frame en el que aparece en escena. Una vez que el usuario es calibrado, NiTE proporciona la siguiente información: Límites del usuario: Proporciona un cubo de volumen mínimo que contiene completamente el usuario. Las coordenadas son proyectivas, por lo que son aptas para su uso directo en un mapa de profundidad. Centro de masa: Permite encontrar el centro geométrico de la masa del usuario. Este valor viene dado en las coordenadas del mundo real, por lo que debe ser convertido antes de ser superpuesto sobre un mapa de profundidad. Pose: Representa toda la información acerca de una postura específica para un usuario concreto. Estado: Este parámetro resultará de vital importancia para filtrar la información proporcionada por NiTE. De esta manera, será posible determinar en qué estado se encuentra un usuario concreto según la Figura 6.20. Es necesario tener en cuenta que cuando un usuario es perdido, su id podrá volver a ser asignado a otro usuario o volver a aparecer en escena con un id diferente. Esqueleto: Está compuesto por un estado y quince articulaciones. • Estado: Al igual que ocurre con el estado del usuario, este valor permitirá filtrar aquellos esqueletos según se encuentren en estado de calibración, calibrados o sin información. • Articulaciones: En la Figura 6.22 se representan las quince posibles articulaciones que pueden ser monitorizadas a través de NiTE. Cada articulación estará compuesta a su vez por: ◦ La orientación y confidence: Estimación de la orientación de una articulación en el espacio y su nivel de precisión. La orientación está representada por un cuaternión (w, x, y, z). El confidence será un valor comprendido entre 0 y 1, siendo 1 el máximo valor de precisión obtenible. ◦ La posición y confidence: Estimación de la posición de una articulación en el espacio y su nivel de precisión. La posición está representada por las coordenadas (x, y, z) en el mundo real. El confidence será un valor comprendido entre 0 y 1, siendo 1 el máximo valor de precisión obtenible. 6.3.2 Evolución del módulo de captura de imágenes En la sección anterior (véase § 6.2) se explicaban los aspectos más importantes sobre O PEN NI y GLUT así como la forma en la que se afrontó la implementación de la primera versión del módulo de captura de imágenes. En las siguientes subseciones se pretende desarrollar los aspectos más relevantes sobre el proceso de integración del middleware NiTE en la solución propuesta y la evolución que ha ido experimentado a lo largo del proyecto. 120 Figura 6.22: Articulaciones detectadas por NiTE [web14u]. Además se presentarán los principales problemas que han ido surgiendo durante su diseño e implementación así como la soluciones que se han propuesto para su solventación. 6.3.2.1. Segunda versión En la primera versión del módulo de captura de imágenes (véase § 6.2.3) se desarrolló la base a partir de la cual se pretende ir incorporando nuevas funcionalidades. Esta primera aproximación tan sólo permitía capturar los flujos de datos RGB y de profundidad capturados por Kinect mediante la plataforma O PEN NI así como su renderizado por pantalla a través del módulo de GLUT (módulo de OpenGL). Sin embargo, el principal objetivo de este módulo no es otro que la capacidad de almacenar, y no sólo mostrar, los datos que son capturados por el dispositivo. Además, se pretende enriquecer esta información recogida mediante los algoritmos que ofrece NiTE acerca del seguimiento de usuarios estudiados en los apartados anteriores. El primer paso que se llevó a cabo para afrontar esta tarea fue definir los hitos esperados de esta nueva iteración del desarrollo del módulo. A continuación se presentan los más significativos: Integración de NiTE: • Seguimiento del esqueleto. • Distinción entre píxeles pertenecientes a un usuario con los que pertenecen al entorno. • Procesamiento de la información de seguimiento. Almacenamiento en ficheros de las imágenes y metadatos. Visualización a través de la interfaz de usuario de la combinación del flujo de datos de 121 profundidad y los esqueletos de los usuarios. Incorporación de nuevos comandos de teclado para permitir interactuar con las nuevas funcionalidades integradas a través de la interfaz de usuario: • Dibujar esqueleto. • Dibujar etiqueta de estado. • Dibujar centro de masa. • Dibujar caja de volumen máximo de un usuario en el espacio. • Dibujar fondo. • Selección de que flujos de datos se desea almacenar. • Iniciar el almacenamiento de los datos capturados. • Mostrar el identificador del frame mostrado por pantalla. Una vez que los hitos que deben ser alcanzados en esta segunda iteración fueron definidos, fue necesario rediseñar algún aspecto del modelo de clases que se propuso anteriormente. Para dar soporte a estas nuevas funcionalidades fue necesario incorporar nuevos métodos que se encargaran de procesar y almacenar los flujos RGB y profundidad junto con sus metadatos en ficheros así como el dibujado del esqueleto. Además, también se realizó un proceso de reestructuración en los métodos ya existentes para integrar los aspectos relacionados con el seguimiento y tratamiento de las articulaciones de los usuarios. En la Figura 6.23 se muestra el modelo de clase resultante tras este proceso de análisis y diseño. Una de las novedades más interesantes que ha sido introducida en esta iteración es la forma en la que se procesa el flujo de datos de profundidad. Hasta el momento, simplemente se renderizaban los datos capturados por el dispositivo tras un simple procesamiento mediante el histograma proporcionado por la plataforma O PEN NI. Sin embargo, NiTE ofrece la posibilidad de distinguir qué puntos pertenecen a un usuario y cuáles pertenecen al entorno que le rodea. De esta forma, resultó muy interesante la idea de introducir una nueva forma de procesar los datos de profundidad capturados por el dispositivo mediante la combinación de ambos procesamientos. Por lo tanto, es posible producir imágenes que distingan entre aquellos píxeles que pertenecen a un usuario y los que pertenecen al entorno pintándolos de una color diferente a la escala de grises. En la Figura 6.24 se muestra el resultado obtenido tras aplicar ambas técnicas de procesamiento. Una técnica muy utilizada en el análisis de secuencia de imágenes es el “background substraction”. Esta técnica consiste la eliminación del fondo o “background” y que para el objetivo de este proyecto sería realmente interesante ya que permitiría eliminar mucho ruido permitiendo así obtener mejores resultados en el clasificador de acciones. Por lo tanto, también se ha introducido la posibilidad de eliminar de la imagen todo aquello que no fueran usuarios pintando de negro aquellos píxeles que no pertenezcan a un usuario (ver Figura 6.25). El resultado obtenido es comúnmente conocido como “blob”.Esto resulta verdaderamente 122 Figura 6.23: Diagrama de clases del módulo de captura de imágenes (versión 2). Figura 6.24: Resultado de la combinación de las técnicas de procesamiento. interesante ya que reducirá sustancialmente la carga en futuras etapas del proyecto debido a que no sería necesario realizar este proceso mediantes técnicas más complejas. De manera similar, es posible combinar las funciones de dibujado de figuras proporcionadas por GLUT y la información acerca de la posición de cada una de las articulaciones de los usuarios facilitada por NiTE. El resultado obtenido se puede observar en las Figuras 6.26 y 6.27. Para conseguir este resultado simplemente ha sido necesario dibujar sobre la imagen de profundidad líneas que unen cada una de las articulaciones capturadas conformando el 123 Figura 6.25: Resultado de la eliminación del fondo. esqueleto aproximado del usuario. Además, se han dibujado etiquetas con las coordenadas correspondientes de cada articulación para obtener de esta forma cierta retroalimentación y poder así comprobar la precisión de las medidas calculadas por NiTE. Por último, para estudiar de manera visual como varía el nivel de “confidence” para cada articulación que se comentaba anteriormente (véase § 6.3.1.2.2) se ha integrado en el dibujado del esqueleto la funcionalidad de variar la intensidad y el color de las líneas en función del valor tomado por este parámetro. Figura 6.26: Dibujado del esqueleto sobre la imagen de profundidad. El último paso que queda para completar esta iteración es el de implementar la funcionalidad de guardado de imágenes tras ser capturadas y procesadas con las técnicas expuestas en los párrafos anteriores. Para llevar a cabo esta tarea se decidió emplear un formato de imagen sencillo que permitiera guardar en crudo los valores obtenidos. Aunque en la siguiente interacción se comprobaría que no se trata de la mejor opción, el formato elegido fue Portable PixMap format (PPM). PPM es un formato de imagen sin comprensión perteneciente a la familia Netpbm diseñado para ser extremadamente fácil de comprender por humanos 124 Figura 6.27: Dibujado del esqueleto eliminando el fondo. y máquinas. A continuación se muestra cómo es la estructura interna de este formato para ejemplificar el porqué de su sencillez: Un “número mágico” que identifica el tipo de fichero (en este caso “P3”). Un espacio en blanco. El ancho de la imagen especificado en caracteres ASCII. Un espacio en blanco. El alto de la imagen especificado en caracteres ASCII. Espacio en blanco. “Maxval”: El valor máximo del color especificado en caracteres ASCII. Valores de los componentes de cada píxel en caracteres ASCII. Como se puede apreciar en el ejemplo 6.4 y su correspondiente imagen (Figura 6.28), PPM es un formato verdaderamente sencillo de entender y procesar. Este hecho permitió poder generar los ficheros sin herramientas especializadas en el tratamiento de imágenes, ya que al estar codificado en ASCII, era posible emplear directamente las funciones facilitadas por las librerías estándar de C++. Además, como ofrece la posibilidad de incluir comentarios dentro del fichero, la inclusión de los metadatos asociados a cada imagen era realmente sencilla de realizar con la ventaja de estar contenida en el mismo fichero que los propios datos. Figura 6.28: Imagen correspondiente al ejemplo 6.4. 125 P3 # The P3 means colors are in ASCII , then 3 columns and 2 rows , # then 255 for max color , then RGB triplets 3 2 255 255 0 0 0 255 0 0 0 255 255 255 0 255 255 255 0 0 0 Listado 6.4: Ejemplo del formato PPM. Por último, para tener organizados los ficheros creados y facilitar así su posterior tratamiento, se ha decidido crear una estructura de directorios que permita separar las imágenes según el tipo de imagen (RGB o de profundidad). Para ello es necesario indicar como argumentos del programa la ruta y el nombre base dónde se desea que trabaje. Como se puede apreciar en la Figura 6.29, se crean dos directorios (uno para cada tipo de imagen) donde se guardarán los ficheros con un nombre significativo. Este nombre estará compuesto por el nombre base que se ha pasado como argumento, el índice dentro de la secuencia de frames que le pertenece y por último una marca temporal. Esta decisión fue tomada para que posteriormente sea posible obtener la información más importante sobre una imagen sin necesidad de abrir el fichero para conocerla. Figura 6.29: Estructura de directorios. 6.3.2.2. Tercera versión La tercera iteración del módulo de captura de imágenes está destinada a la mejora y corrección de problemas. Tras la realización de diversas pruebas de rendimiento, se identificaron dos contratiempos importantes: Pérdida de frames debido al procesamiento y la generación de los frames y de los ficheros. 126 Consumo de memoria excesivo de los ficheros PPM de las imágenes RGB y de profundidad. No obstante, debido a la complejidad y a la gran variedad de cambios que supone la resolución de estos dos problemas, se ha decidido abordarlos por separado posponiendo la solución al problema del excesivo consumo de memoria para la siguiente iteración. En primer lugar, es importante destacar que la pérdida de frames es un problema potencialmente crítico para el sistema que se está desarrollando ya que se estarían produciendo saltos en los datos capturados que impedirían obtener la secuencia completa de una acción y, por lo tanto, espacios temporales en los que el sistema no tendrá información que cotejar. Como ya se trató en la sección acerca de las especificaciones técnicas (véase § 4.1.4), Kinect tiene una tasa de captura de 30 frames por segundo. Por consiguiente, teóricamente se deben generar y procesar aproximadamente tres mil ficheros por segundo. No obstante, estas cifras son siempre teóricas ya que alcanzar esta tasa es realmente difícil debido a diversas causas: Retrasos debidos a la comunicación entre Kinect y el ordenador. Las características técnicas del ordenador (procesador, tarjeta gráfica, etc.) y otros procesos que se encuentren ejecutando en ese momento.. y NiTE introduce carga computacional al realizar tareas de preprocesado y refinamiento en los datos capturados. O PEN NI El procesamiento que se le está realizando a cada frame y su posterior almacenamiento se está llevando a cabo de manera secuencial. Como se puede apreciar, el problema más evidente que está produciendo esta gran pérdida de frames es el procesamiento secuencial. Para solucionar este problema es necesario tener claro cuál es el orden lógico en la realización de las diversas tareas que se están llevando a cabo. Como se puede apreciar en la Figura 6.30, cuando se capturan los frames RGB y de profundidad correspondientes, estos no vuelven a ser capturados hasta que no se hayan realizado todas las tareas de procesado de las imágenes y almacenamiento en ficheros PPM. Es en este momento cuando resulta crucial el buen entendimiento acerca de cómo funciona O PEN NI y NiTE, ya que cuando alguno de ellos recibe un frame, este se encontrará accesible sólo hasta que otro nuevo frame sea recibido. Por ejemplo, si en un momento dado se están procesando los frames 13500 y 13521, cuando estos terminen su tratamiento correspondiente, los siguientes frames que estarán disponibles podrían ser el 14001 y 140022. De este modo, esos 501 frames que no han sido solicitados ya no podrán ser recuperados. La solución propuesta a este problema consiste en paralelizar algunos aspectos en el tratamiento de las imágenes. De este modo, se podrán diferenciar tres tipos de hilos que han sido implementado mediante la librería POSIX: 127 Figura 6.30: Modelo de flujo de la ejecución secuencial. Hilo principal: Encargado de recoger los frames disponibles y realizar las tareas principales del programa. Hilo procesamiento RGB: Encargado de procesar el frame RGB enviado por el hilo principal y generar el fichero PPM correspondiente. Hilo procesamiento profundidad: Encargado de procesar el frame de profundidad enviado por el hilo principal y generar el fichero PPM correspondiente. De esta forma, cada vez que el hilo principal recibe nuevos frames generará dos nuevos hilos (uno por cada tipo de frame) y almacenará sus referencias en una lista. Posteriormente, cuando el hilo principal reciba una señal de finalización, esperará a que todos los hilos para los que tiene una referencia almacenada en la lista hayan terminado. Como se puede apreciar, entre los hilos hijos nunca habrá problemas de sincronización ya que el orden en que se ejecuten o terminen no afectará a los demás ni al resultado esperado. Tras realizar de nuevo las pruebas de rendimiento, se observa que la tasa de frames que son procesados ha aumentado sustancialmente consiguiendo no perder ningún frame ofrecido por O PEN NI y NiTE. De este modo, se ha logrado solucionar el problema de pérdida de frames alcanzando una tasa de procesamiento por encima de la necesaria para lograr una secuencia de imágenes óptima para su posterior tratamiento y clasificación por acciones. 128 Figura 6.31: Modelo de flujo de la ejecución concurrente. 6.3.2.3. Cuarta versión Como ya se adelantaba anteriormente, se ha identificado un serio problema que provoca un consumo excesivo de memoria. De esta forma, uno de los principales objetivos de esta nueva iteración será el de encontrar una solución apropiada a este problema así como llevar a cabo los cambios que puede acarrear. Además, se aprovechará para introducir una nueva funcionalidad que será de gran utilidad para el posterior reconocimiento de acciones. Anteriormente se explicó como se estructuraba internamente PPM. Además también se indicaba que este formato no utilizaba ningún tipo de comprensión. Este detalle es muy importante, ya que debido a la resolución de imagen con la que se está trabajando, se generarán ficheros realmente pesados. Para ser más concretos, tras realizar diversas pruebas se ha establecido que los ficheros resultantes se encuentran con un tamaño que oscila aproximadamente entre tres y cuatro megabytes. Para ser más conscientes del impacto que puede conllevar este tamaño de fichero, se han realizado diversas pruebas para comprobar el comportamiento real que presenta el módulo con este formato de imagen. A continuación se muestra una tabla con los resultados más relevantes (ver Cuadro 6.2). En vista de los resultados obtenidos, este consumo es totalmente insostenible a largo plazo ya que mover tal cantidad de ficheros con este tamaño sería terriblemente lento además de las 129 Tiempo (minutos) No ficheros Tamaño total (MB) 0,5 1 3 5 10 1300 2694 8673 12461 26643 4680 9429 32090.1 48587.9 102309.3 Cuadro 6.2: Resultados obtenidos con ficheros PPM. grandes cantidades de espacio de almacenamiento que requeriría. La solución al problema pasa por emplear un formato de imagen más eficiente y que permita conservar la sencillez y versatilidad que ofrecía PPM. Tras realizar un pequeño estudio de las diferentes posibilidades existentes, se ha llegado a la conclusión de que el formato de imagen más conveniente para el módulo de captura de imágenes es JPEG. JPEG, además de ser un formato de archivo, es un método de comprensión que utiliza habitualmente un algoritmo de compresión con pérdida para reducir el tamaño de los archivos de imágenes. Esto quiere decir que al descomprimir o visualizar la imagen, no se obtiene exactamente la misma imagen de la que se partía antes de la compresión. No obstante, existen también tres variantes del estándar JPEG que comprimen la imagen sin pérdida de datos como pueden ser JPEG2000, JPEG-LS y Lossless JPEG. Tras realizar diferentes pruebas para encontrar el equilibrio perfecto entre calidad y tamaño, se pudo comprobar que para los objetivos del proyecto bastaba con emplear JPEG y no sus variantes. De esta forma, se asume que la pérdida de calidad en la imagen que supone la utilización de esta técnica de comprensión no resultará ningún problema para la etapa de reconocimiento de acciones. Una vez que el nuevo formato a utilizar estaba claro, llega el momento de integrarlo en el módulo. Para acometer esta tarea se han empleado las funcionalidades ofrecidas por OpenCV, biblioteca libre enfocada en la visión artificial. La decisión de emplear OpenCV estaba basada en que proporcionaba un entorno de desarrollo fácil de utilizar y altamente eficiente, además de la interoperabilidad que ofrece al tratarse de una distribución multiplataforma disponible para GNU/Linux, Mac OS X y Windows. Una vez que esta nueva funcionalidad ya ha sido integrada en el módulo, se han vuelto a realizar las mismas pruebas de rendimiento que se realizaron con los ficheros PPM observando que la mejora en el consumo de memoria e incluso en el rendimiento que presenta el módulo durante su ejecución ha sido realmente impactante. A continuación se muestra una tabla con los resultados más relevantes (ver Cuadro 6.3). En Figura 6.32 y Figura 6.33 se muestran unas gráficas comparativas de las estimaciones realizadas para el número de ficheros y tamaño en Megabytes respectivamente según el tipo de formato. 130 Tiempo (minutos) No ficheros Tamaño total (MB) 0,5 1 3 5 10 1594 3190 9564 15944 31882 68 159 443.4 709.5 1434.7 Cuadro 6.3: Resultados obtenidos con ficheros JPEG. Figura 6.32: Gráfico comparativo del no de ficheros entre el formato PPM y JPEG. No obstante, al introducir esta mejora es necesario realizar más cambios en el módulo. Hasta este momento todos los metadatos generados para cada frame eran almacenados como un comentario en el interior del fichero PPM correspondiente al frame. Sin embargo, con JPEG esta opción no es una alternativa viable. Por lo tanto se han tenido que plantear diferentes soluciones que permitieran almacenar la imagen y su correspondiente metainformación de una manera eficiente y sencilla de procesar posteriormente. Las alternativas mas viables son las siguientes: Generación de un contenedor multimedia en el que se almacenará en forma de vídeo los diferentes frames junto su correspondiente metainformación. Generación de dos ficheros por cada frame de profundidad: • Fichero JPEG correspondiente al frame. • Fichero XML que contenga la metainformación correspondiente al frame. Aunque la primera opción resulta realmente atractiva ya que tan sólo sería necesario ge131 Figura 6.33: Gráfico comparativo del tamaño total en megabytes entre el formato PPM y JPEG. nerar un solo fichero de vídeo para cada flujo de información, en las etapas siguientes del proyecto se comprobará que esta no es la mejor solución ya que será necesario trabajar a nivel de fichero de imagen por cada frame capturado. Por lo tanto, se ha decidido integrar la funcionalidad al módulo de almacenar esta metainformación a través de ficheros XML. Para llevar a cabo esta tarea, el primer paso que ha sido necesario acometer es decidir qué librería es la mas interesante para perder el mínimo de eficiencia posible. De este modo, se ha realizado un análisis de las principales alternativas existentes para el lenguaje de programación que está siendo empleado para el desarrollo de este módulo (C++). A continuación se presenta un breve resumen de las librerías más interesantes así como sus principales características: Xerces6 : Ofrece una gran cantidad de funcionalidades (especialmente cuando es combinada con Xalan), pero por el contrario es muy pesada y fuerza al programador a la gestión de memoria. RapidXML7 : Excelente para realizar tareas de análisis in situ, pero no es una opción eficiente en la generación de ficheros XML. Boost XML8 : Herramienta potente y excelente sintaxis de C++. Sin embargo, el soporte y documentación acerca de la librería es insuficiente. 6 http://xerces.apache.org/ http://rapidxml.sourceforge.net/ 8 http://svn.boost.org/svn/boost/trunk/boost/ 7 132 Libxml9 : Buena herramienta para la generación, pero es demasiado pesada si tan solo se requieren realizar tareas de generación de ficheros XML. XiMOL10 : Herramienta fácil de emplear, aunque para realizar ciertas funciones puede resultar demasiado simple. TinyXML11 : Herramienta de licencia libre, ligera, simple e independiente del sistema operativo. Tras este análisis, se ha decidido emplear la librería TinyXML debido a que es la solución que presenta un mayor equilibrio entre sencillez, tamaño y versatilidad. Una vez que se ha decidido que TinyXML es la solución más apropiada para integrar la funcionalidad de generación de ficheros XML en el módulo de captura de imágenes, es el momento de diseñar la estructura más conveniente de estos ficheros. En el Listado 6.5 se muestra cuál ha sido la estructura elegida, intentando en todo momento generar ficheros que sean fáciles de manejar e interpretar. Para finalizar esta iteración, y cómo ya se anticipaba antes, se ha aprovechado para introducir una nueva funcionalidad al módulo. Esta funcionalidad consiste en ofrecer la posibilidad de generar ficheros de imagen en la cual sólo se represente el esqueleto correspondiente a los usuarios que aparecen en la escena (ver Figura 6.34). Para ello, se ha hecho uso de las funciones ofrecidas por la librería OpenCV y la metainformación proporcionada por el middleware NiTE acerca de la posición aproximada de las articulaciones de los usuarios detectados. De esta forma, fue necesario incluir algún método al modelo de clases así como rediseñar la forma en la que se construía la estructura de directorios. En el Anexo § B se muestran las versiones definitivas de ambos diseños. 6.4 Iteración 4: Módulo de reconocimiento de acciones En esta sección se expone cómo se ha llevado a cabo el diseño e implementación del módulo de reconocimiento de acciones. Para ello se ha dividido en dos subsecciones que se distribuyen de la siguiente manera: La primera describe el modelo conceptual que se ha seguido así como sus principales características. Es muy importante mencionar que se ha empleado el trabajo desarrollado por Jesús Martínez Del Rincón, Jean-Christophe Nebel y María Jesús Santofimia Romero12 , por lo que no ha sido necesario llevar el desarrollo desde cero sino adaptarlo a la solución requerida. En la segunda se expone el proceso que se ha seguido para la correcta implementación del mismo. A lo largo de esta subsección se detallaran las diferentes fases y etapas en las que se 9 http://xmlsoft.org/ http://ximol.sourceforge.net/ 11 http://www.grinninglizard.com/tinyxml/ 12 Código facilitado en la estancia de María José Santofimia Romero en la Kingston University London en Digital Imaging Research Centre (DIRC) durante el año 2011. 10 133 < frame > < timestamp > XXX </ timestamp > < frame_index > XXX </ frame_index > < users > < user > < id > XXX </ id > < isNew > XXX </ isNew > < isVisible > XXX </ isVisible > < isLost > XXX </ isLost > < skeleton_state > XXX </ skeleton_state > < joints > < joint_head > < position > < positionx > XXX </ positionx > < positiony > XXX </ positiony > < positionz > XXX </ positionz > < po s i t io n _ co n f id e n ce > XXX </ p os i t i on _ c on f i de n c e > </ position > < orientation > < orientationx > XXX </ orientationx > < orientationy > XXX </ orientationy > < orientationz > XXX </ orientationz > < orientationw > XXX </ orientationw > < o r i e n t a t i o n _ c o n f i d e n c e > XXX </ o r i e n t a t i o n _ c o n f i d e n c e > </ orientation > </ joint_head > ... </ joints > </ user > < user > ... </ user > </ users > </ frame > Listado 6.5: Estructura fichero XML. ha dividido el módulo acompañado de diversas comparativas, descripción de las herramientas utilizadas además de numerosos diagramas que facilitarán su completa comprensión. Finalmente se describe con un alto nivel de detalle los aspectos más relevantes de la solución generada así como el funcionamiento interno de los diversos submódulos de los que está compuesto. 6.4.1 Modelo Bag of Words Entre las diferentes técnicas de aprendizaje que pueden ser aplicadas para realizar la tarea de reconocimiento de acciones humanas [WBR07] [YKS08], el framework Bag of Words (B OW) [Joa98a] [CDF+ 04] es particularmente adecuado para el desarrollo del módulo de reconocimiento de acciones del presente proyecto. Se ha demostrado que B OW [KB10] [LAS08] [LP07] es uno de los métodos más precisos para el reconocimiento de acciones, 134 Figura 6.34: Funcionalidad introducida en el módulo (versión 4). capaz de actuar en una gran variedad de escenarios con un coste computacional realmente bajo. Al contrario de otras técnicas de clasificación, B OW no requiere ningún algoritmo adicional de segmentación, lo cuál simplifica la tarea de visión por computador haciendo, por lo tanto, posible trabajar directamente con datos de vídeo. Como consecuencia, la metodología de B OW ha sido elegida cómo base del presente módulo de visión por computador para el reconocimiento de acciones. Es importante destacar que el modelo B OW surgió como una aproximación motivada en métodos de categorización de texto [Joa98b] [TK02] [LSST+ 02] [CSTL02]. Sin embargo, la idea de adaptar la categorización de texto a la categorización de vídeo no es algo nuevo. Un ejemplo de ello es [ZRZ02] dónde se investigó la cuantificación y caracterización de vectores de pequeñas ventanas cuadradas en imágenes llamadas keyblocks. En este estudio demostraron que estas características producían más resultados orientados a la semántica que las aproximaciones basadas en el color y la textura cuando realizaban la combinación con histogramas y modelos análogos de la categorización de texto. No obstante, a diferencia del enfoque que se propone a continuación, los keyblocks que generaban no poseían propiedades de invarianza. En los siguientes párrafos se describe la aproximación basada en estás técnicas que ha sido llevada para la implementación del módulo de reconocimiento de acciones. Para ello se hará uso de unos simples gráficos que ayudarán a facilitar la comprensión del modelo propuesto. En la Figura 6.35 se muestra el estado inicial del ejemplo. 135 Figura 6.35: Imágenes originales. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. En la categorización de vídeo, de manera similar a la mayoría de las técnicas de aprendizaje, B OW confía en la etapa de entrenamiento para aprender a discriminar características de una secuencia de vídeo y en la etapa de clasificación que permitirá llevar a cabo el proceso de reconocimiento. De esta forma, la etapa de entrenamiento que se presenta en este proyecto consiste en tres pasos bien diferenciados: Creación de un codebook de descriptores de características, generación de un descriptor por cada vídeo que representa una acción disponible en el dataset de entrenamiento y finalmente entrenar el clasificador con los descriptores de los vídeos que hayan sido obtenidos. De esta forma, el flujo de trabajo comenzará con la extracción de las características en cada vídeo previamente etiquetado perteneciente al dataset de entrenamiento (ver Figura 6.36). Figura 6.36: Extracción de características. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. Una vez que los las características hayan sido extraídas de los vídeos, se lleva a cabo un proceso de clustering [KMN+ 02] para agrupar y cuantificar los descriptores obtenidos y así generar un diccionario (codebook) que proporcionará el vocabulario mediante el cual los datos serán descritos (ver Figura 6.37). Finalmente, cada vídeo del dataset de entrenamiento es descrito en términos de las nuevas “palabras” del diccionario generado y que posteriormente será empleado para realizar el proceso de entrenamiento de un clasificador lineal Support Vector Machines (SVM). De esta forma, el clasificador SVM aprenderá por cada acción defi136 nida el hiperplano óptimo que permita obtener la mejor separación entre los diferentes tipos de acciones. Figura 6.37: Generación del diccionario (clustering). Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. Durante la etapa de clasificación propuesta, las acciones realizadas en los vídeos a analizar serán reconocidas mediante la aplicación de un procedimiento similar al empleado en la etapa de entrenamiento. Mediante la aplicación de una técnica de extracción de características que será descrita en los siguientes apartados se obtendrán los conjuntos de característicos más significativos de cada secuencia de vídeo. Posteriormente, estas características serán cuantificadas usando el diccionario (codebook) para generar los descriptores que caracterizan a cada secuencia de vídeo (ver Figura 6.38). Finalmente, estos descriptores serán entregados al clasificador SVM con el fin último de cuantificar la similitud entre cada nueva secuencia de vídeo y cada tipo de acción para las que haya sido entrenado (ver Figura 6.39). Como resultado se obtendrá una lista de etiquetas que describirán el la acción que se está realizando en el vídeo. 137 Figura 6.38: Cuantificación de características. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. Figura 6.39: Clasificador SVM. Extraídas de “Bag-of-words models” (S. Lazebnik, A. Torralba, L. Fei-Fei, D. Lowe, C. Szurka) y adaptadas por Rubén Cantarero Navarro. 6.4.2 Implementación de la solución propuesta Una vez que los conceptos clave del modelo B OW para el reconocimiento de acciones expuesto en el apartado anterior ha sido entendido, es el momento de llevar a cabo su implementación. Para ello se han empleado diferentes herramientas como “FFmpeg”, “stipdept”, “Ann”, “bsvm”, etc que serán descritas en las siguientes subsecciones a lo largo de cada fase del proceso en el que son empleadas. No obstante, es importante destacar que para conectar cada una de estas fases y llevar a cabo todo el procedimiento se ha empleado Practical Extraction and Report Language (PERL). PERL es un lenguaje de propósito general que toma características del lenguaje C, del lenguaje interpretado bourne shell (sh), AWK, sed, Lisp y, en un grado inferior, de muchos otros lenguajes de programación. Originalmente fue desarrollado para la manipulación de texto y que hoy en día también es ampliamente utilizado para realizar una gran variedad de tareas incluyendo administración de sistemas, desarrollo web, programación en red, desarrollo de GUI, etc. Entre sus principales, características las más destacadas son que es fácil de usar, soporta tanto la programación estructurada como la programación orientada a objetos y la programación funcional, tiene incorporado un poderoso sistema de procesamiento de texto y una enorme colección de módulos disponibles. A continuación se exponen algunas de las 138 ventajas más destacadas que se han deducido tras realizar un breve análisis sobre PERL: Reduce el ciclo de programación: No es necesario compilar la aplicación, PERL es interpretado y por ello, los programas pueden ser ejecutados en muchas plataformas sin necesidad de ser recompilado. Es portable: Hay un interpretador de PERL para cada variedad de Unix y Windows, por lo que los cambios que deben ser realizados a una aplicación escrita en este lenguaje son mínimos o nulos. Potencia y sencillez: Permite realizar muchas tareas que serían más complejas en otros lenguajes como C o Shell, como por ejemplo la manipulación de archivos de texto. La sintaxis: La sintaxis de otros lenguajes como Shell, Sed, AWK o C es muy similar a la de PERL. Inclusive cuenta con herramientas para traducir código de Sed y AWK a PERL de manera automática. Extensible: Hay una gran variedad de módulos disponibles que pueden ser incluidos en las aplicaciones de manera muy sencilla, dando además la posibilidad de desarrollar módulos propios. Gratuito. Como se puede apreciar, las ventajas que ofrece PERL son numerosas. No obstante, una de las más importantes y que ha sido decisiva en la decisión de emplear PERL y no otro lenguaje es su gran destreza en el procesado de texto y manipulación de archivos además de su portabilidad. En los siguientes apartados se podrá valorar como esta característica será crucial para el desarrollo de los scripts necesarios de una manera cómoda, sencilla y eficiente. Por el contrario, ha sido necesario llevar a cabo un trabajo extra ya que la utilización de este lenguaje conlleva una curva de aprendizaje alta debido a la gran cantidad de funcionalidades que ofrece. Para llevar a cabo la implementación de un sistema basado en el modelo de B OW ha sido necesario analizar y diseñar las diferentes fases de las que está compuesto este procedimiento y que este módulo de reconocimiento de acciones deberá llevar a cabo (ver Figura 6.40). Desde un punto de vista con un nivel de abstracción más elevado se pueden distinguir las siguientes: Configuración inicial: Preparación del entorno para llevar a cabo las tareas necesarias. Segmentación de vídeos: Tratamiento de los vídeos para su posterior procesamiento. Extracción de características: Obtención de los descriptores que caracterizan a una secuencia de vídeo. Clustering: Realización del proceso de clustering con los descriptores obtenidos. 139 Proceso de reconocimiento/clasificación: Fase de clasificación de las acciones a partir de un clasificador Support Vector Machines (SVM). Figura 6.40: Diagrama de flujo de la solución propuesta. No obstante, cada una de estas fases del módulo de reconocimiento de acciones así como la subtareas de más bajo nivel en las que se subdividen serán descritas en las siguientes subsecciones con todo nivel de detalle. Un concepto importante que debe ser entendido son las etapas o modalidades en las que se divide el proceso necesario para llevar a cabo el reconocimiento y clasificación de acciones. De esta forma se pueden distinguir dos etapas que estarán compuestas por algunas de las diferentes fases descritas anteriormente. Por lo tanto, este módulo de reconocimiento de acciones deberá dar soporte a ambas modalidades permitiendo realizar las fases correspondientes en función de la etapa que se este llevando a cabo. La etapa inicial, también conocida como etapa de “training”, es la encargada de entrenar al sistema para el posterior reconocimiento y clasificación de acciones que será llevado a cabo en la siguiente etapa. Por lo tanto, esta etapa de entrenamiento deberá ser realizada tan 140 solo una vez para obtener los elementos que serán requeridos en la realización de la segunda etapa. Para ello generará los siguientes elementos a partir de un dataset de entrenamiento: Clusters: Asocia el resultado entre los descriptores de los vídeos de entrenamiento y los clusters que son formados, generando de esta forma el diccionario o codebook. Posteriormente, en la siguiente etapa estos clusters serán empleados para medir la distancia con los clusters obtenidos de los descriptores generados mediante los vídeos de prueba. Modelo: Este modelo será empleado en la segunda etapa por el clasificador SVM. De esta forma, el modelo generado permitirá al clasificador desempeñar su tarea a partir del cual distinguirá a qué tipo de acción se corresponde en función de este modelo los datos que le son pasados. La segunda etapa, también conocida como etapa de “testing”, será realizada tantas veces como conjuntos de vídeos se desee procesar y clasificar. Para ello, hará uso de los elementos obtenidos en la etapa de entrenamiento que servirán como base para tomar las decisiones necesarias en las fases de clustering y clasificación de la segunda etapa. Aunque ambas etapas serán desgranadas en mayor profundidad en las siguientes subsecciones a través de la explicación de las diferentes fases de las que se componen, este concepto de training y testing es clave para comprender el proceso necesario para la realización de la clasificación de acciones basado en el modelo de B OW descrito anteriormente. En la Figura 6.41 se presenta una visión general del orden y los pasos requeridos en este proceso. Como se puede apreciar, ambas etapas se encuentran bien diferenciadas. Aunque las fases que deben llevarse a cabo son similares, los resultados y finalidad de alguna de ellas difieren un poco. A continuación se presenta a modo de resumen las principales diferencias entre ambas etapas para facilitar la comprensión de este proceso: Datos de entrada: En la etapa de training se emplea un dataset de entrenamiento mientras que en la etapa de testing se emplea el conjunto de vídeos que se desea clasificar. Número de veces que se realiza: La etapa de training se realiza una vez para entrenar al sistema a través de la generación de los elementos de clustering y el modelo del clasificador SVM, mientras que la etapa de testing se realiza tantas veces como conjuntos de vídeos se desee clasificar. Fase de clustering (Fase 4): En la etapa de training se obtiene un conjunto de clusters a partir de los descriptores de los vídeos del dataset de entrenamiento obtenidos en la fase de extracción de características, mientras que en la etapa de testing se emplea estos clusters obtenidos en la etapa de training para procesar los descriptores de los vídeos que se desean clasificar obtenidos en la fase de extracción de características. 141 Fase de reconocimiento (Fase 5): En la etapa de training se obtiene un modelo para el clasificador SVM de las acciones definidas para ser clasificadas, mientras que en la etapa de testing se usa en el clasificador SVM el modelo obtenido en la etapa de training para clasificar en función de las acciones previamente definidas. Figura 6.41: Diagrama de flujo de según las etapas. Una vez que se han presentado brevemente las diferentes fases a las que este módulo de reconocimiento de imágenes debe dar soporte así como las dos etapas necesarias para llevar a cabo el proceso de clasificación, es el momento de definir las acciones que se desean de identificar. Para ello, se ha empleado las acciones definidas por el dataset INRIA Xmas Motion Acquisition Sequences (IXMAS)13 . IXMAS es un dataset público desarrollado por Institut National de Recherche en Informatique et en Automatique (INRIA) y que será empleado posteriormente para llevar a cabo la etapa de training. No obstante, este dataset será explicado con mayor detalle así como el proceso seguido para el entrenamiento en el capítulo de resultados (véase § 7). A continuación se describen las quince acciones de la vida cotidiana definidas por IXMAS así como su correspondiente identificador que será empleado más adelante en el proceso de etiquetado: (0) Nada: No se está realizando ninguna acción. El usuario está parado. (1) Mirar reloj: El usuario realiza la acción de mirar el reloj de su muñeca. (2) Cruzarse de brazos: El usuario realiza la acción de cruzarse de brazos. (3) Rascarse la cabeza: El usuario realiza la acción de rascarse la cabeza. (4) Sentarse: El usuario realiza la acción de sentarse en el suelo. 13 http://4drepository.inrialpes.fr/public/viewgroup/6 142 (5) Levantarse: El usuario realiza la acción de levantarse. (6) Darse la vuelta: El usuario realiza la acción de darse la vuelta sobre sí mismo. (7) Caminar: El usuario realiza la acción de caminar. (8) Saludar: El usuario realiza la acción de saludar con su mano. (9) Dar puñetazo: El usuario realiza la acción de dar puñetazos. (10) Dar patada: El usuario realiza la acción de dar patadas. (11) Señalar: El usuario realiza la acción de señalar con el dedo. (12) Coger: El usuario realiza la acción de coger algo del suelo, una mesa, etc. (13) Lanzar: El usuario realiza la acción de lanzar algo sobre su cabeza. (14) Lanzar: El usuario realiza la acción de lanzar algo de abajo hacia arriba. Con todos los conceptos analizados y entendidos, tan solo queda un tarea antes de comenzar a desarrollar cada una de las fases que componen las etapas de training y testing anteriormente descritas: Definir la estructura interna del módulo de reconocimiento de acciones. Para ello se ha decidido implementar diferentes submódulos o scripts que serán los encargados de realizar las tareas especificas de cada fase. De este modo, habrá un programa principal (“run_all”) encargado de gestionar y ejecutar cada uno de los submódulos desarrollados mediante PERL. A continuación se muestra una lista de estos submódulos según la fase a la que pertenecen y que en los siguientes apartados serán explicados (ver Figura 6.42): Fase de segmentación de vídeos: build_segmented_videos. Fase de extracción de características: avi2stip, stip2featuredescriptors y stip2hof. Fase de clustering: new_sequence_cluster_choice_k. Fase de reconocimiento/clasificación: all_rcg_same_file, norm_hist_smallut2libsvm, norm_hist_biglut2libsvm y recognition_from_cluster_all. El principal motivo por el que se ha seguido este diseño es tener todas las fases y sus tareas correspondientes bien compartimentadas, facilitando de este modo su comprensión, manipulación y depuración. Además, gracias a este diseño se pueden definir cuáles son las entradas y salidas de cada submódulo o tarea, ofreciendo por lo tanto la capacidad de remplazar un módulo concreto por otro cuyas entradas y salidas sean las mismas. Este hecho ha sido realmente útil a lo largo del proyecto ya que permite depurar la solución propuesta así como solucionar los errores que se han ido identificado. 6.4.2.1. Fase 1: Configuración inicial Esta fase será idéntica tanto para la etapa de training como para la etapa de testing. Aunque esta fase no es parte del modelo de B OW, sino una fase específica del sistema a desarrollar, su 143 Figura 6.42: Módulos del sistema. realización es crucial ya que su principal objetivo es el de preparar todo el entorno del sistema para llevar a cabo las siguientes fases. Para ello se limpian los directorios correspondientes borrando los archivos generados de anteriores ejecuciones y creando a su vez los directorios correspondientes para la nueva ejecución, dejando así un estado consistente para obtener un correcto funcionamiento. En la Figura 6.43 se representa cómo es la estructura interna de directorios en el que trabajará el sistema. Como se puede apreciar, se ha intentado mantener una estructura similar a las diferentes fases de las que se compone el proceso de reconocimiento/clasificación de vídeos. Esta decisión de diseño ha sido de vital importancia ya que el sistema procesará y generará una gran cantidad de archivos a lo largo del proceso y por lo tanto mantener todo organizado será crucial para obtener un código claro y comprensible en los diferentes submódulos. 6.4.2.2. Fase 2: Segmentación de vídeos Esta fase será idéntica tanto para la etapa de training como para la etapa de testing. Para desempeñar esta fase se ha desarrollado un programa en PERL (buil_segmented_videos) que será ejecutado por el programa principal tantas veces como ficheros de texto haya disponibles en el directorio /videos/truth. Estos ficheros tendrán un nombre con una estructura concreta, ACTOR_frame_segmented.txt, dónde “ACTOR” será el nombre del vídeo. La estructura interna de estos ficheros también se encuentra predefinida: Cada línea estará compuesta por el número del frame donde comienza la acción, un espacio en blanco, el número de frame donde finaliza la acción, un espacio en blanco y el identificador de la acción que se está lle144 Figura 6.43: Estructura de directorios de la solución propuesta. vando a cabo (véase § 7.1). En el Listado 6.6 se muestra un pequeño ejemplo para facilitar su comprensión: Frames del 0 al 220: El usuario no esta realizando ninguna acción. Frames del 220 al 271: El usuario se encuentra caminando. Frames del 271 al 310: El usuario ha cogido algún objeto. Frames del 310 al 327: El usuario está caminando 1 2 3 4 0 220 0 220 271 7 271 310 12 310 327 7 Listado 6.6: Estructura fichero ACTOR_frame_segmented.txt. La finalidad del programa build_segmented_videos es segmentar los vídeos que contienen una secuencia de acciones (se encuentran en el directorio /videos) para los cuáles hay un fichero en el directorio /videos/truth en vídeos más pequeños correspondientes a una única 145 acción. Para indicar cómo deben ser descompuestos estos vídeos se hace uso del fichero correspondiente donde se indican los frames de inicio y fin de la acción. Para realizar esta tarea será necesario en primer lugar descomponer cada vídeo a segmentar en frames, los cuales serán almacenados temporalmente en el directorio /videos/segmented_videos/images/ con un nombre significativo que permita posteriormente ser procesadas por un procesador de vídeo. Como la tasa de frames por segundo es conocida (en el caso de Kinect es de 30 frames/segundo), se obtendrán treinta imágenes por cada segundo de vídeo. Finalmente, el fichero de vídeo resultante tras unir estos frames en vídeos será almacenado en el directorio /videos/segmented_videos/ACTOR/ACTOR_indice_identificadorDeAcción.avi. En la Figura 6.44 se muestra un diagrama de fujo dónde se muestra el proceso llevado a cabo por este programa. Figura 6.44: Diagrama de flujo de build_segmented_videos. Continuando con el ejemplo anterior, el proceso que se seguiría para descomponer un vídeo llamado pepe.avi con su correspondiente fichero pepe_frame_segmented.txt (ver Listado 6.6) sería el siguiente: 146 Paso 1: Se crea un directorio llamado pepe en /videos/segmented_videos/. Paso 2: Se crea un directorio llamado images en /videos/segmented_videos/. Paso 3: Se fragmenta el vídeo /videos/pepe.avi en frames que serán almacenados en /videos/segmented_videos/images/. Paso 4: Se crea un vídeo en el que el usuario no hace nada llamado pepe_000_0.avi en /videos/segmented_videos/pepe/ a partir de los frames correspondientes almacenados en /videos/segmented_videos/images/. Paso 5: Se crea un vídeo en el que el usuario está andando llamado pepe_001_7.avi en /videos/segmented_videos/pepe/ a partir de los frames correspondientes almacenados en /videos/segmented_videos/images/. Paso 6: Se crea un vídeo en el que el usuario ha cogido algún objeto llamado pepe_002_12.avi en /videos/segmented_videos/pepe/ a partir de los frames correspondientes almacenados en /videos/segmented_videos/images/. Paso 7: Se crea un vídeo en el que el usuario está andando llamado pepe_003_7.avi en /videos/segmented_videos/pepe/ a partir de los frames correspondientes almacenados en /videos/segmented_videos/images/. Paso 8: Se elimina el directorio /videos/segmented_videos/images/. Como se puede apreciar, para descomponer cada vídeo con las secuencias de acciones en vídeos con una sola acción es necesario descomponerlo antes en frames que serán almacenadas en imágenes. No obstante, llegados a este punto del proyecto y como ya se anticipaba anteriormente (véase § 6.3.2.3) se ideó una forma para que este proceso no fuera necesario llevarlo a cabo y así tener una menor carga computacional en el módulo de reconocimiento de acciones. La solución consiste en almacenar los flujos de información capturados por los sensores de Kinect directamente en imágenes por cada frame. Una vez incorporada esta modificación en el módulo de captura de imágenes, ya no será necesario este preprocesado de los vídeos. Finalmente, tan solo destacar que el procesador de vídeo empleado para realizar todas estas tareas de segmentación de vídeos es FFmpeg14 . FFmpeg es un proyecto de software libre muy popular para el tratamiento de datos multimedia que es utilizado en importantes proyectos como son VLC, MPlayer, HandBrake, Blender, Google Chrome y muchos más. Concretamente el componente que ha sido empleado es ffmpeg, una potente herramienta de línea de comandos que permite realizar conversiones entre formatos de vídeo y audio. 6.4.2.3. Procesamiento Una vez que se ha preparado el entorno del sistema y se han dividido las secuencias de vídeo a analizar en vídeos de una sola acción, ya está todo preparado para llevar a cabo el 14 http://www.ffmpeg.org/index.html 147 procesamiento de los mismos siguiendo el modelo B OW expuesto al comienzo de la sección (véase § 6.4.1). Al contrario de lo que ocurría con las fases de configuración y segmentación, en las siguientes fases ya se introducen pequeñas diferencias en función de la etapa del procesamiento en la que se encuentre el sistema: training o testing. No obstante, a lo largo de la descripción de cada fase se describirá en detalle cuáles son esas diferencias y su finalidad. Llegado este punto, el programa principal (run_all) se encargará de ejecutar las siguientes fases para cada uno de los vídeos originales una vez que se hayan generado los vídeos segmentados en la fase anterior. En la Figura 6.45 se representa a muy alto nivel cómo serán las fases del procesamiento así como las entradas y salidas de cada una en función de la etapa en la que se encuentre el sistema, donde ya se pueden apreciar las principales diferencias que caracterizarán a cada etapa. Figura 6.45: Fases de procesamiento. 6.4.2.3.1. Fase 3: Extracción de características Antes de comenzar con la implementación de esta fase ha sido necesario llevar a cabo un primer paso para realizar una exhaustiva investigación y completo análisis sobre las técnicas existentes para extraer las características más significativas de una secuencia de vídeo y así poder decidir cuál es la más apropiada para el sistema que se está desarrollado. En los siguientes párrafos se exponen las conclusiones más importantes que se han extraído de este análisis y el proceso llevado a cabo para aplicar la técnica escogida. De este modo, el primer paso descrito por el modelo de B OW quedará implementado. Cómo ya se comentaba en el capítulo de antecedentes (véase § 4.2), el análisis e interpretación de vídeo es un tema en continúa evolución y crecimiento en el campo de visión por computador. Los enfoques tradicionales para el análisis de movimiento en secuencias de vídeo implican principalmente el cálculo del flujo óptico [BFB94] o el seguimiento de características [SB95] [IB98]. Aunque son efectivas para muchas tareas, ambas técnicas tienen limitaciones. Las aproximaciones basadas en el flujo óptico capturan el primer orden de movimiento y por lo tanto a menudo fallan cuando se producen movimientos repentinos. La soluciones basadas en el seguimiento de características generalmente asumen una apa148 riencia constante en la imagen a lo largo del tiempo y por lo tanto se producen importantes fallos cuando esta apariencia constante cambia, como por ejemplo en situaciones en la que dos objetos de la imagen se unen o dividen. De forma contraría a lo que exponen las anteriores técnicas, la mayoría de los eventos de interés que se producen en una secuencia de vídeo están caracterizados por importantes variaciones en los datos de las dimensiones tanto espacial como temporal. Ejemplos de ello podrían ser escenas en las que una persona entra a una habitación, una persona se sienta, etc. En el domino espacio-temporal, el cálculo de puntos con variaciones significativas en las intensidades de una imagen han sido extensamente investigadas en el pasado [FG87] [HS88] [SMB00]. Este tipo de puntos son comúnmente denominados como “puntos de interés”, los cuales constituyen importantes fuentes de información debido a la gran cantidad de información que proporcionan para el análisis de vídeo. Como muestra de las posibilidades que ofrecen este tipo de puntos de interés y el importante éxito que han tenido, se han desarrollado una gran variedad de aplicaciones: indexado de imágenes [SM97], estimación del flujo óptico y seguimiento [SB95] y reconocimiento [Low99] [HVC00]. Siguiendo este razonamiento, la aproximación que se ha decidido seguir para extraer las características de las secuencias de vídeo a analizar ha sido la extracción de puntos de interés espacio-temporales, también conocida cómo Space-time Interest Points (STIP). Esta aproximación fue presentada por Ivan Laptev en 2005 [Lap05] basándose en la idea de puntos de interés desarrollada por Harris y Stephens en 1988 (conocido como algoritmo Harris3D [SB11]). Con esta técnica es posible detectar estructuras espacio-temporales donde los valores de las imágenes de una secuencia de vídeo representan variaciones significativas en la dimensión espacio-temporal. Estos puntos resultan especialmente interesantes ya que se centran en unos pocos puntos específicos de las imágenes que componen un vídeo. De esta forma, mediante la integración de la componente del tiempo es posible llevar a cabo un filtrado de los puntos de interés obtenidos y mantener tan solo aquellos que tienen una discontinuidad temporal. Por lo tanto, los puntos de interés de una imagen estarán definidos como píxeles con variaciones máximas de la intensidad en los píxeles vecinos, representando esquinas, intersecciones, puntos asilados y puntos específicos en la textura de la imagen. De esta forma, es posible extrapolar esta definición a los STIPs si se consideran una secuencia de vídeo en vez de una imagen. Consecuentemente, los STIPs pueden ser definidos como píxeles con cambios significativos en el espacio y tiempo, otorgando la posibilidad de representar movimientos irregulares del cuerpo humano como rodillas, hombros, etc. La técnica que se ha empleado en la presente fase del proyecto para generar los STIPs consiste en la búsqueda de puntos que maximicen la variación local de los valores de una imagen sobre las dimensiones espacio-temporal de manera simultanea. De acuerdo con la teoría de 149 Laptev, una secuencia de vídeo podrá ser por tanto representada mediante la función f : R2 xR → R (6.3) sobre dos dimensiones espaciales (x,y) y una dimensión temporal t. De esta manera, las características locales espacio-temporales quedan definidas cómo bloques tridimensionales de secuencias que contienen variaciones en el espacio y el tiempo. Una vez que se ha decidido la técnica que va a ser empleada para la extracción de características de las secuencias de vídeo, es el momento de implementar la solución propuesta. Es importante destacar que esa fase será idéntica para las etapas de training y testing, ya que tanto para el dataset de prueba como para las secuencias de vídeo a clasificar será necesario extraer las características. Para ello se han elaborado tres programas en PERL (avi2stip, stip2featuredescriptors y stip2hof ) que serán ejecutados por el programa principal. En la Figura 6.46 se representa la secuencia que debe ser llevada a acabo para la generación de los descriptores que serán empleados en la siguiente fase (clustering). Figura 6.46: Diagrama de la fase de extracción de características. El programa avi2stip será el encargado de generar los ficheros que contengan los STIP’s. En primer lugar, creará un directorio con el mismo nombre del vídeo original concatenado con la terminación _stip en /extracted_features. El siguiente paso que llevará a cabo será la generación de un fichero STIP para cada segmento del vídeo original que se este proce150 sando mediante el uso de la herramienta stipdept. stipdept es una aplicación desarrollada por Ivan Laptev15 cuya finalidad es calcular los descriptores para cada uno de los puntos de interés espacio-temporal del vídeo que le es pasado como argumento. Este programa permite integrar la técnica elegida en los párrafos anteriores para la extracción de características. El resultado obtenido a través de esta herramienta consiste en dos tipos descriptores, Histograms of Oriented Gradients (HOG) y Histograms of Optical Flow (HOF), calculados mediante cuadros de vídeo tridimensionales para cada STIP detectado. Estos cuadros se encuentran divididos en bloques espacio-temporales de 3x3x2. Los descriptores HOG estarán compuestos por setenta y dos elementos mientras que los descriptores HOF por noventa. Tan solo destacar que los parámetros con los que es ejecutado stipdept serán analizados con mayor detenimiento en el capítulo de resultados (véase § 7). Aunque la herramienta stipdept permite ver de forma muy visual y en tiempo de ejecución los puntos de interés que se van calculando sobre el vídeo (ver Figura 6.47), por motivos de eficiencia esta opción no será utilizada normalmente ya esta visualización supone una carga computacional importante. No obstante fue de gran utilidad en los primeros pasos para afianzar los conceptos de STIP y examinar también su comportamiento. Figura 6.47: Captura de stipdet de una imagen de profundidad capturada con Kinect. Este fichero “.stip” generado para cada fragmento de vídeo mediante esta herramienta será almacenado en el directorio /extracted_features/ACTOR_stip/ con el nombre “nombreVideoSgemnetado.stip”. Posteriormente los programas stip2featuredescriptors y stip2hof serán los encargados de extraer de los ficheros .stip los descriptores HOF que serán utilizados en la fase de clustering. Para ello, simplemente deben desechar la cabecera del fichero .stip y los siguientes setenta y dos elementos que se corresponden con los descriptores HOG. Los resultados obtenidos serán almacenados en un nuevo fichero en el directorio /extracted_fea15 http://www.di.ens.fr/~laptev/index.html 151 tures/ACTOR_fearure_descriptors/ con el nombre nombreVideoSgemnetado.hof. 6.4.2.3.2. Fase 4: Clustering Esta fase se encargará de la realización del proceso de clustering con los descriptores HOF obtenidos en la fase anterior. Para ello se ha implementado un programa en PERL (new_sequence_cluster_choice_k) con ciertas variaciones en función de la etapa, training o testing, en la que se encuentre el sistema. Como ya se adelantaba anteriormente, la principal diferencia entre ambas modalidades reside en el procesamiento que se dan a los descriptores y el resultado que es obtenido. En la fase de clustering correspondiente a la etapa de training se generarán los clusters característicos para cada una de las secuencias de vídeo que representan las diferentes acciones que se pretenden clasificar con el sistema que se está desarrollando. Para ello se emplearán los descriptores resultantes de la fase de extracción de características de los vídeos proporcionados por el dataset de entrenamiento. De esta forma, se está llevando a cabo la tarea del aprendizaje del vocabulario visual que se presentaba en modelo B OW. Como resultado se obtienen los archivos clusters_hof_300.pts (codebook) y biglut.lut. La fase de clustering correspondiente a la etapa de testing se encarga de realizar la asociación entre el conjunto de descriptores obtenidos en la fase anterior a partir de la secuencia de vídeos que se pretende clasificar y los resultados obtenidos en la fase de clustering en la etapa de training. Para ello hará uso del fichero clusters_hof_300.pts obtenido en la fase de clustering de la etapa de training y de una de las herramientas de ANN. ANN 16 es una librería escrita en C++ destinada a ofrecer estructuras de datos y algoritmos para el cálculo de la búsqueda de vecinos próximos en ámbitos que presentan un elevado número de dimensiones. La razón por la que se ha decidido hacer uso del algoritmo de búsqueda aproximada de vecinos próximos se debe principalmente a que la realización del cálculo exacto en dimensiones mayores de ocho se convierte en una tarea realmente compleja y con una alta carga computacional. De esta forma, pocos métodos parecen ser significativamente mejores que el cálculo mediante fuerza bruta de todas las distancias. Sin embargo, se ha mostrado en diversas ocasiones que realizando un cálculo aproximado de los vecinos más próximos es posible lograr tiempos de ejecución significativamente mejores (en el orden de 10 a 100 veces mejor) con errores relativamente pequeños. De esta forma se ha hecho uso de una las aplicaciones distribuidas junto a la librería ANN para realizar este cálculo. A través de la línea de comandos se le indican los diferentes parámetros que se desea que se tengan en cuenta a la hora de realizar el cálculo. A continuación se exponen los que han sido empleados en el presente proyecto: 16 http://www.cs.umd.edu/~mount/ANN/ 152 Dimensiones del espacio: Este valor se encuentra definido por el numero de elementos del descriptor HOF obtenido en la fase de extracción de características. Número máximo de puntos de datos: Valor definido en por el descriptor HOF. Nombre del fichero que contiene los puntos de datos: Fichero “.hof” calculado en la fase de extracción de características en la etapa de testing. Nombre del fichero que contiene los puntos de consulta: Fichero clusters_hof_300.pts obtenido en la fase de extracción de características en la etapa de training. Una vez proporcionados los datos, la aplicación de ANN construirá una estructura de árbol de búsqueda, leerá los puntos de consulta y posteriormente realizará el cálculo aproximado del k vecino más próximo para cada uno con un error . El resultado obtenido consistirá en los índices y las distancias de cada punto de consulta con respecto los puntos de datos. Teniendo claro cuál va a ser la técnica empleada para calcular a qué cluster pertenece cada descriptor y su funcionamiento, es el momento de llevar a cabo su implementación. Para ello el programa new_sequence_cluster_choice_k realizará los siguientes pasos: Paso 1: Obtiene la dimensión de los descriptores a partir de los ficheros .hof generados en la fase anterior. Paso 2: Crea un fichero smallut.lut en el directorio clustering/. Este fichero representa una Look Up Table (LUT) que representa la asociación entre cada descriptor y la acción que representa y que será empleado posteriormente en la fase de clasificación para preprocesar los datos que serán pasados al clasificador SVM. Paso 3: Por cada fichero .hof almacenado en el directorio /extracted_features/ACTOR_feature_descriptors realizará las siguientes operaciones: • Obtiene el número máximo de puntos de datos del descriptor contenido en el fichero .hof que será pasado como parámetro a la herramienta ANN. • Almacena en una LUT local este número máximo y que posteriormente será empleado para normalizar el histograma generado en el siguiente paso. • Almacena en el fichero smallut.lut el número de acción correspondiente al fichero .hof que se está procesando. • Ejecuta ANN con los parámetros descritos en los párrafos anteriores y almacena su resultado en un fichero llamado nombreDelFicheroHOF/nearest_cluster_300.hofpts en el directorio /clustering/nearest_neighbour/. Paso 4: Consiste en la construcción del histograma de clusters para cada secuencia. Para ello por cada fichero .hofpts generado en el paso anterior construirá su histograma correspondiente y lo almacenará temporalmente en una variable local. Paso 5: Consiste en normalizar los histogramas generados en el paso anterior. Para ello se hará uso del número máximo de puntos de datos de cada descriptor almacenado 153 en la variable LUT generado en el Paso 3 y del histograma generado en el Paso 4. Una vez normalizado el histograma, será almacenado en un fichero llamado nombreDelFicheroHOF_histogram_norm_300.hofhist en el directorio /clustering/histograms/. En la Figura 6.48 se muestra un diagrama en el que se representan los diferentes pasos que acaban de ser descritos. De este modo, el paso de la cuantificación de características descrito anteriormente en el modelo B OW queda completado. Figura 6.48: Diagrama de new_sequence_cluster_choice_k 6.4.2.3.3. Fase 5: Proceso de reconocimiento Esta fase se encargará de llevar a cabo el proceso de clasificación de las acciones mediante 154 un clasificador SVM. Al igual que ocurría en la fase anterior, existirán diferencias importantes en función de la etapa en la que se encuentre el sistema. Para la implementación de esta fase se han empleado diferentes programas desarrollados en PERL que se encargarán de llevar a cabo el preprocesamiento de la información obtenida en la fase de clustering para que pueda ser empleada finalmente por el clasificador SVM. En la Figura 6.49 se muestra un diagrama que representa la secuencia de ejecución de los diferentes programas así como las entradas y salidas de cada uno. En los siguientes apartados serán descritos con mayor detalle en función de la etapa en la que sean ejecutados. No obstante, antes de entrar en los detalles de cada etapa y de cómo funcionan internamente estos programas es necesario tener en cuenta algunos conceptos. El primero de ellos es conocer los aspectos más básicos sobre el funcionamiento de un clasificador SVM. Ya que no se va a implementar un clasificador desde cero, sino que se va a emplear una solución ya existente, tan solo será necesario tener una idea básica sobre su funcionamiento. Los algoritmos SVM pertenecen a la familia de los clasificadores lineales. De este modo, dado una colección de puntos (subconjunto de un conjunto mayor) en el que cada uno de ellos pertenece a una de las posibles categorías definidas, un algoritmo basado en la técnica SVM construirá un modelo capaz de predecir si un nuevo punto (cuya categoría a la que pertenece se desconoce a priori) pertenece a una categoría u otra previamente definida en el modelo. Para llevar a cabo este proceso, el algoritmo SVM buscará un hiperplano que permita separar de la manera más óptima los puntos pertenecientes a cada una de las clases o categorías las cuales normalmente pueden haber sido proyectadas a un espacio de dimensionalidad superior. No obstante, es importante destacar que este concepto de separación óptima es donde realmente reside la característica fundamental de los algoritmos SVM: Buscan el hiperplano que posea la máxima distancia o margen con los puntos que se encuentren más cercanos de él mismo. Es por este motivo por el que este tipo de algoritmos también son conocidos como clasificadores de margen máximo. Una vez que se tiene una idea aproximada sobre el funcionamiento de los algoritmos SVM, llega el momento de decidir qué implementación del clasificador SVM va a ser empleado en la solución propuesta. Para ello se hizo un pequeño estudio de la soluciones existentes. Entre las más destacadas y conocidas se encuentran LIBSVM, SVMTorch II, mySVM, Dlib C++ Library y SVMLigth. Sin embargo, debido a su robustez y a la gran cantidad de funcionalidades que ofrece se ha decidido emplear la distribución BSVM desarrollada por Chih-Chung Chang y Chih-Jen Lin [HL02b] [HL02a]. Según su especificación, la implementación actual de BSVM toma prestada la estructura interna de LIBSVM ofreciendo de este modo opciones muy similares. Para solventar algunas de las limitaciones con las que se encuentra LIBSVM en el proceso de clasificación y regresión, BSVM implementa un método interno de descomposición y una selección múltiple de conjuntos de trabajo dando como resultado convergencias más rápidas en los casos más 155 complejos. Esta implementación ofrece dos herramientas, bsvm-train y bsvm-predict17 , que serán empleadas para las etapas de training y testing respectivamente. Aunque los parámetros necesarios para configurar el clasificador serán desarrollados con mayor detalle en los siguientes apartados, es necesario conocer antes el formato en el que deben ser pasados los datos a estas herramientas (ver Listado 6.7). Estos datos son pasados por medio de un fichero compuesto de los siguientes elementos: Label: Es el valor objetivo de los datos de entrenamiento. Para la clasificación debe ser un número entero que identifica una clase, mientras que para la regresión debe ser cualquier numero real. En el archivo de datos de prueba (testing) sólo se utilizan para calcular precisión. Si no se conocen, esta columna debe de ser rellenada con cualquier número. Index: Es un entero que comienza con el valor 1. Sirven para enumerar los elementos value. Value: Es un número real. < label > < index1 >: < value1 > < index2 >: < value2 > ... < label > < index1 >: < value1 > < index2 >: < value2 > ... . . . < label > < index1 >: < value1 > < index2 >: < value2 > ... Listado 6.7: Estructura fichero de datos del clasificador SVM. De esta forma, el fichero empleado en la etapa de training deberá tener tantos tipos de elementos label como clases distintas se quieran identificar, en este caso quince (véase § 6.4.2). Por el contrario, en la etapa de training en principio puede ser cualquier número entero al azar ya que a priori no se conoce a qué clase pertenece el elemento en cuestión. A continuación se muestra un ejemplo para entender mejor como funciona esta codificación: Imagine que se tienen dos puntos (x,y) bidimensionales, (0,3) y (5,8), que pertenecen a clases diferentes (1 y 2 respectivamente) y se desea codificarlos para que pueda ser llevado a cabo el proceso de clasificación. En la Listado 6.8 se presenta como debería ser el fichero correspondiente según la etapa en la que se vaya a emplear: Etapa de training En la etapa de training se generará un modelo a partir de los datos obtenidos en la fase anterior (clustering) y que posteriormente será empleado para llevar a cabo el proceso de 17 http://www.csie.ntu.edu.tw/~cjlin/bsvm/ 156 // Etapa de training 1 1 :0 2 :3 2 1 :5 2 :8 // Etapa de testing < Entero cualquiera > 1 :0 2 :3 < Entero cualquiera > 1 :5 2 :8 Listado 6.8: Ejemplo de la estructura fichero de datos del clasificador SVM. clasificación por el clasificador SVM. Siguiendo el esquema planteado en la Figura 6.49, el primer programa a ejecutar es all_rcg_same_file cuyo propósito para esta etapa no es otro que el de preparar el entorno del sistema para que todo se encuentre en un estado correcto e invocar al siguiente programa en ejecutarse: nom_hist_biglut2libsvm. Este programa tiene como objetivo preprocesar los datos y dotarles del formato pertinente para que posteriormente puedan ser empleados por el clasificador SVM. Para ello, deberá emplear los ficheros generados en la etapa de clustering: biglut.lut (contiene una LUT en la cual asocia cada histograma con su identificador de acción correspondiente) y clustering_hist_norm_hof_300.hist (contiene todos los histogramas normalizados). A continuación se describen los pasos que han sido necesarios para realizar correctamente este tratamiento: Paso 1: Crear fichero learn_hist_norm_hof_300_libsvm en el directorio /recognition_process/. Paso 2: Por cada línea del fichero clustering_hist_norm_hof_300.hist: • Paso 2.1: Dividir la línea leída por elementos (separados por un espacio en blanco). • Paso 2.2: Incluir en el fichero learn_hist_norm_hof_300_libsvm el siguiente número de acción leído del fichero biglut.lut. Este elemento incluido en el fichero representa el <label>. • Paso 2.3: Por cada cada elemento obtenido en el paso 2.1: ◦ Paso 2.3.1: Incluir en el fichero learn_hist_norm_hof_300_libsvm un índice (comienza desde 1) seguido por “:”, el siguiente elemento y un salto de línea. Estos elementos incluidos en el fichero representan el <indexN> y el <valueN>. Por último debe ejecutarse el programa recognition_from_cluster_all. En la etapa de training este programa deberá generar el modelo correspondiente a los datos que le son pasados y que posteriormente será empleado por la etapa de testing. Para ello, simplemente deberá emplear la herramienta bsvm-train incluida en la distribución bsvm. A continuación se indican algunos de los parámetros más importantes para su configuración: Fichero de datos de entrenamiento: Fichero learn_hist_norm_hof_300_libsvm ge157 nerado por el programa nom_hist_biglut2libsvm. Tipo de kernel: Lineal (u0 ∗ v). Coste: Valor empleado descrito en el capítulo de resultados (véase § 7). bsvm-train generará cómo resultado el modelo correspondiente al fichero de datos de entrenamiento en el archivo learn_hist_norm_hof_300_libsvm_model_KERNEL_COST en el directorio /recognition_process/results/. Etapa de testing En esta etapa finalmente se determinará a qué clase pertenece cada uno de los segmentos de vídeo que se generaron al comienzo de todo el proceso en base al modelo obtenido en la etapa de training. Para ello, siguiendo el esquema propuesto en la Figura 6.49, el primer programa a ejecutar es all_rcg_same_file cuyo propósito para esta etapa es producir un archivo que contenga todos los histogramas de los vídeos segmentados generados en la fase de clustering y lanzar el programa nom_hist_smallut2libsvm. Este archivo se ubicará en el directorio /recognition_process/ con el nombre learn_hist_norm_hof_300t. De manera similar a nom_hist_biglut2libsvm, el programa nom_hist_smallut2libsvm tiene como objetivo preprocesar los datos y dotarles del formato pertinente para que posteriormente puedan ser empleados por el clasificador SVM. Para ello, deberá emplear el fichero generado en la etapa de clustering smallut.lut (contiene una LUT en la cual asocia cada histograma con su identificador de acción correspondiente) y el fichero learn_hist_norm_hof_300t (contiene todos los histogramas normalizados) generado por el programa all_rcg_same_file. A continuación se describen los pasos que han sido necesarios para realizar correctamente este tratamiento: Paso 1: Crear fichero learn_hist_norm_hof_300t_libsvm en el directorio /recognition_process/. Paso 2: Por cada línea del fichero learn_hist_norm_hof_300t: • Paso 2.1: Dividir la línea leída por elementos (separados por un espacio en blanco). • Paso 2.2: Incluir en el fichero learn_hist_norm_hof_300t_libsvm el siguiente número de acción leído del fichero smallut.lut. Este elemento incluido en el fichero representa el <label>. Este valor sólo es obligatorio en el caso de que se quiera obtener el grado de precisión en el clasificador. • Paso 2.3: Por cada cada elemento obtenido en el paso 2.1: ◦ Paso 2.3.1: Incluir en el fichero learn_hist_norm_hof_300t_libsvm un índice (comienza desde 1) seguido por “:”, el siguiente elemento y un salto de línea. Estos elementos incluidos en el fichero representan el <indexN> y el <valueN>. 158 El último paso a realizar es llevado a cabo por el programa recognition_from_cluster_all. A diferencia del comportamiento que presentaba en la etapa de training, en esta ocasión debe emplear la herramienta bsvm-predict proporcionada por la distribución BSVM. Para ello se le deben facilitar dos archivos: Fichero de datos: Archivo learn_hist_norm_hof_300t_libsvm generado por el programa nom_hist_smallut2libsvm. Modelo: Archivo learn_hist_norm_hof_300_libsvm_model_KERNEL_COST generado en la etapa de training por el programa recognition_from_cluster_all. Como resultado se obtendrán otros dos archivos ubicados en el directorio /recognition_process/results/ : classified_result_KERNEL_COST_hof_300_ACTOR: Contiene los índices (véase § 6.4.2) que identifican la acción predicha para cada fragmento de vídeo. accuracy_KERNEL_COST_hof_300_ACTOR: Contiene el porcentaje de acierto/precisión obtenido en la predicción de cada fragmento de vídeo. 6.5 Iteración 5: Interfaz gráfica En la presente sección se pretende desarrollar una interfaz gráfica para los diferentes módulos que se han explicado en las secciones anteriores. El principal objetivo es el de facilitar la integración y manipulación de las diferentes funcionalidades desarrolladas y adaptadas a lo largo del proyecto. De esta forma, mediante una interfaz de usuario amigable será posible trabajar con los diferentes módulos de una manera más cómoda y sencilla. Para ello se ha empleado la plataforma Qt. Qt es una biblioteca multiplataforma ampliamente usada para desarrollar aplicaciones con interfaz gráfica de usuario, así como también para el desarrollo de programas sin interfaz gráfica, como herramientas para la línea de comandos y consolas para servidores. Además, Qt ha sido desarrollada como software libre y de código abierto a través de Qt Project18 . Qt es utilizada en KDE, entorno de escritorio para sistemas como GNU/Linux o FreeBSD. No obstante, una de las características que hace realmente interesante la utilización de esta plataforma es que Qt utiliza el lenguaje de programación C++ de forma nativa. Una vez que se ha elegido la plataforma y el lenguaje de programación a emplear, es el momento de analizar y diseñar cuáles van a ser las funcionalidades que debe soportar e implementar esta herramienta. La interfaz de usuario que se propone está organizada en diferentes pestañas para separar de una forma muy intuitiva las diferentes funcionalidades que se presentan en la aplicación. A continuación se describen brevemente en los siguientes apartados. 18 http://qt-project.org/ 159 Captura de vídeo La funcionalidad principal de esta pestaña es la de realizar la captura de vídeo a través del dispositivo Kinect. Para ofrecer una mayor flexibilidad al usuario, se ha ofrecido la posibilidad de seleccionar mediante los diálogos correspondientes la ruta en la que se desea almacenar los resultados obtenidos así como el nombre del actor del que se va a realizar la captura. Una vez que toda esta información ha sido facilitada por el usuario, simplemente será necesario ejecutar de forma interna el módulo de captura de vídeo desarrollado (véase § 6.3.2.3) con los parámetros indicados por el usuario. Como ya se expuso anteriormente, este módulo da como resultado los diferentes frames capturados en formato JPEG. Es por ello por lo que también se ha incluido la posibilidad de, una vez que se han llevado el proceso de captura, transformar estos ficheros JPEG en el vídeo correspondiente. De esta forma, indicando simplemente la ruta donde se encuentran los resultados de las diversas capturas y la correspondiente al directorio /BoW 19 , se generarán los vídeos correspondientes dejándolos preparados para su posterior procesamiento por el módulo de reconocimiento de acciones. Finalmente también se ha incluido un área para facilitar al usuario la retroalimentación pertinente de realizar los diferentes procesos descritos en los párrafos anteriores. En la Figura 6.50 se muestra una captura de la pestaña de “Captura de vídeo”. Etiquetado de vídeo En esta pestaña se ofrece al usuario la posibilidad de realizar la tarea de etiquetado de vídeo de una forma bastante sencilla. Para lograrlo se ha integrado todas las herramientas que son necesarias en una única interfaz como se puede apreciar en la Figura 6.51. De esta forma, el usuario tendrá acceso a un pequeño reproductor de vídeo con funcionalidades muy interesantes para facilitar su trabajo. Algunas de las más destacadas son: Lista de reproducción integrada. Controles de pausa, rebobinado, sonido, etc. Control de velocidad de la reproducción. Barra de información de la reproducción (tiempo del vídeo, tiempo restante, etc.) Visualización del frame actual y posibilidad de saltar a un frame concreto. Herramientas de modificación del color. Reproducción en pantalla completa. Histograma. 19 En el directorio /BoW se encuentran los correspondientes directorios y ejecutables del módulo de reconocimiento de acciones. 160 También se ha integrado un pequeño editor de texto para generar los ficheros ACTOR_frame_segmented.txt descritos en la sección anterior (véase § 6.4.2.2). De esta forma el usuario tendrá todo lo necesario para etiquetar los vídeos en una única interfaz sin necesidad de manejar un reproductor de vídeo y editor de texto por separado. No obstante, aunque el usuario tendrá la posibilidad de editar el fichero directamente en este editor integrado, se ha incluido una funcionalidad extra que facilitará aún más su trabajo. Esta nueva funcionalidad consiste en proporcionar la posibilidad de que, sin necesidad de ir deteniendo la reproducción del vídeo, sea posible ir editando el fichero ACTOR_frame_segmented.txt de una manera muy mecánica y sencilla. Para ello se han introducido dos botones que permiten seleccionar el frame actual del vídeo que se esté reproduciendo y una lista seleccionable de las diferentes acciones posibles. De esta forma, cuando el usuario haya indicado los frames de inicio y fin de la acción así como la acción correspondiente, estos serán introducidos directamente en el editor. Para asegurar que el fichero generado mantiene la coherencia se han incluido diversos mecanismos que comprueban los elementos incluidos. Clasificación En esta pestaña se ofrece al usuario la posibilidad de ejecutar el módulo de reconocimiento de acciones. Para ello, una vez haya realizado las funciones incluidas en las dos pestañas anteriores, el usuario simplemente deberá seleccionar la ruta donde se encuentra el directorio /BoW. Finalmente también se ha incluido un área para facilitar al usuario la retroalimentación pertinente de realizar el proceso de reconocimiento de acciones. En la Figura 6.52 se muestra una captura de la pestaña de “Clasificación”. Inspector de resultados Esta pestaña está pensada para facilitar la revisión de los resultados obtenidos en el proceso de reconocimiento. Para ello el usuario simplemente deberá facilitar la ruta donde se encuentra el directorio /BoW. El programa se encargará, de forma transparente para el usuario, de procesar todos los resultados que se encuentren disponibles en el directorio /BoW proporcionado y mostrarlos de una manera amigable para el usuario. De esta forma, esta última pestaña se ha organizado en tres columnas (ver Figura 6.53): Vídeos: Lista que permite seleccionar el vídeo (para el cual hay resultados) del que se desean visualizar los resultados. Etiquetado: Tabla que muestra el contenido del fichero ACTOR_frame_segmented.txt correspondiente al vídeo seleccionado. 161 Resultado: Tabla que muestra el resultado obtenido del vídeo seleccionado tras llevar a cabo el proceso de clasificación. Esta tabla esta compuesta por dos columnas. La primera indica la acción predicha (de forma textual, no con el índice correspondiente), mientras que la segunda indica si dicha predicción es correcta o no. Para facilitar aún más la comprobación de si los resultados obtenidos son correctos se han empleado diferentes colores (rojo para el incorrecto y verde para el correcto). Finalmente, también se proporcionará el nivel de precisión (Accuracy) de cada vídeo si este se encuentra disponible. 162 Figura 6.49: Diagrama de la fase 163de proceso de reconocimiento. Figura 6.50: Funcionalidad de Grabación. Figura 6.51: Funcionalidad de etiquetado. 164 Figura 6.52: Sección de clasificación. Figura 6.53: Sección de Resultados. 165 Capítulo 7 Resultados E el presente capítulo se describen los resultados obtenidos tras realizar las pruebas de precisión al sistema elaborado, además del proceso seguido para su correcta realización. Para ello se han empleado los módulos implementados a lo largo del proyecto (módulo de captura de imágenes y módulo de reconocimiento de acciones). De este modo, se ha decidido dividir el capítulo en las siguientes secciones: N Dataset de entrenamiento empleado. Recogida de datos de prueba. Análisis de los resultados. Además, también se proporciona al lector la opción de acceder al repositorio (véase https: //bitbucket.org/arco group/tfg.ruben.cantarero) donde se encuentran todos los recursos generados a lo largo del proyecto. 7.1 Dataset de entrenamiento empleado En primer lugar es necesario destacar que los vídeos empleados en el estudio deben representar escenarios lo más realistas posible. Esto se debe a que el principal objetivo es llevar a cabo un experimento de reconocimiento de acciones que son relevantes en la vida real. Es por este motivo por lo que es muy importante elegir un conjunto de entrenamiento adecuado. De este modo el conjunto de entrenamiento debe cubrir la mayor variedad de puntos de vista de la cámara, proporcionando de este modo un entrenamiento independiente del punto de vista. Además, este conjunto también debe cubrir una cantidad suficientemente grande de casos que representen las acciones que interesan para el presente estudio. Por último este conjunto de datos debe estar etiquetado, segmentado y organizado. Tras realizar una profunda búsqueda y análisis de los datasets disponibles se ha llegado a la conclusión de que los más adecuados y que mejor se ajustan a los requisitos buscados son INRIA Xmas Motion Acquisition Sequences (IXMAS) [WRB06] y Hollywood [LMSR08]. El conjunto de entrenamiento Hollywood está orientado hacia la detección de eventos incluyendo acciones significativas pero independientes unas de otras (comer, besar, conducir un coche, correr, etc.). Por el contrario, el dataset IXMAS está centrado en acciones realiza167 das en un entorno cerrado ofreciendo de este modo una descripción de las acciones posibles muy exhaustiva. Por lo tanto, las acciones ofrecidas en IXMAS pueden ser combinadas para descibir actividades simples como dar patadas, puñetazos, andar, sentarse, etc. y además proporciona representaciones completas de un conjunto de acciones realizadas de forma individual. Asimismo, por ser un dataset ampliamente utilizado, permite comparar y validar el sistema propuesto. Por consiguiente, se ha decidido emplear el dataset IXMAS para realizar la etapa de entrenamiento del sistema. Este conjunto de entrenamiento está compuesto por trece tipos de acciones realizadas por doce actores diferentes. Además, cada acción se encuentra grabada de forma simultanea por cinco cámaras diferentes (ver Figura 7.1). A continuación se muestra un listado de las acciones reconocidas: (0) Nada: No se está realizando ninguna acción. El usuario está parado. (1) Mirar reloj: El usuario realiza la acción de mirar el reloj de su muñeca. (2) Cruzarse de brazos: El usuario realiza la acción de cruzarse de brazos. (3) Rascarse la cabeza: El usuario realiza la acción de rascarse la cabeza. (4) Sentarse: El usuario realiza la acción de sentarse en el suelo. (5) Levantarse: El usuario realiza la acción de levantarse. (6) Darse la vuelta: El usuario realiza la acción de darse la vuelta sobre sí mismo. (7) Caminar: El usuario realiza la acción de caminar. (8) Saludar: El usuario realiza la acción de saludar con su mano. (9) Dar puñetazo: El usuario realiza la acción de dar puñetazos. (10) Dar patada: El usuario realiza la acción de dar patadas. (11) Señalar: El usuario realiza la acción de señalar con el dedo. (12) Coger: El usuario realiza la acción de coger algo del suelo, una mesa, etc. (13) Lanzar: El usuario realiza la acción de lanzar algo sobre su cabeza. (14) Lanzar: El usuario realiza la acción de lanzar algo de abajo hacia arriba. 7.2 Recogida de datos de prueba Como ya se anticipaba al comienzo del capítulo, se van a emplear dos datasets de acciones diferentes para evaluar el sistema: Dataset IXMAS y uno capturado mediante el dispositivo Kinect. El primero de ellos será empleado para llevar a cabo la etapa de entrenamiento o “training”, mientras que el segundo servirá como conjunto de datos para las pruebas o “testing” (véase § 6.4.2). El principal motivo de esta decisión se basa en que mediante el uso de 168 Figura 7.1: Ejemplo de IXMAS. [wbI14] dos datasets considerablemente diferentes es posible mostrar la generalidad, las capacidades y el rendimiento del sistema desarrollado en el presente proyecto. Para recoger este segundo conjunto de datos para el proceso de testing se ha empleado el módulo de captura de imágenes desarrollado en el proyecto (véase § 6.2 y § 6.3). De esta forma, ha sido posible generar un conjunto de entrenamiento propio: “KinbehrDataset”. El primer paso necesario para la creación de este dataset fue la preparación del escenario en el que iban a tener lugar las grabaciones. Como se puede apreciar en la Figura 7.2 el escenario consiste en una única habitación que dispone de los siguientes elementos: Un libro: Consiste en un libro de crucigramas con la intención de captar la atención de los actores durante la grabación y potenciar así la realización de la acción coger. Una silla: Puede ser utilizada y movida por los actores durante la grabación. De este modo se pretende animar a los actores a realizar la acción sentarse. Un saco de boxeo: Puede ser empleada por los actores durante la grabación. La forma más natural de interaccionar con él es mediante puñetazos y patadas. Una pelota: Puede ser empleada por los actores durante la grabación. La forma más natural de interaccionar con ella es botándola o lanzarla al aire o contra las paredes para así realizar la tarea de lanzar o tirar algo. Mediante la introducción de estos elementos en el escenario se pretende diseñar un dataset que sea lo más representativo posible respecto de la inmensa variabilidad de acciones de la vida real, sin perder en ningún momento de vista que debe contener la mayoría de las acciones integradas en el dataset IXMAS con el que ha sido entrenado el sistema. De esta manera se conduce a los actores a que de forma natural interaccionen con los elementos que interesan para los objetivos del sistema. Un ejemplo de ello podría ser como el actor encuentra el libro, lo recoge (acción coger) y se sienta a leerlo (acción sentarse). Otro ejemplo 169 Figura 7.2: Escenario de grabación empleado. también podría ser como el actor ve el saco de boxeo y empieza a jugar con el dándole patadas y puñetazos (acción patada y acción puñetazo). Una vez que el escenario estaba preparado se comenzó con el proceso de grabación. Para ello se convocó a quince actores de diferentes estaturas, peso y sexo para obtener la mayor variedad posible. En el Cuadro 7.1 se muestra un resumen con la información más relevante. Actor 1 Actor 2 Actor 3 Actor 4 Actor 5 Actor 6 Actor 7 Actor 8 Actor 9 Actor 10 Actor 11 Actor 12 Actor 13 Actor 14 Actor 15 Edad Sexo Peso (Kg) Altura (m) No de acciones 21 23 20 19 20 20 24 22 22 23 25 28 22 23 23 M M M H H H H H M M H H H H H 60 52 65 98 64 80 96 73 52 76 74 68 82 84 98 1.63 1.67 1.65 1.84 1.74 1.77 1.85 1.80 1.65 1.67 1.82 1.72 1.75 1.87 1.85 80 102 121 192 123 73 64 66 98 47 115 53 74 93 52 Cuadro 7.1: Información y número de acciones realizado por cada actor. Es importante mencionar que este proceso de grabación fue dividido en dos partes bien diferenciadas con objetivos diferentes. De esta forma, por cada actor se realizaban dos procesos de grabación: 170 Grabación en entorno no guiado: En este proceso de grabación no se le daba ningún tipo de instrucción al actor. De este modo, se dejaba al actor en la habitación con el lema “tienes 8 minutos para hacer lo que quieras”. Grabación en entorno guiado: En este proceso se iba solicitando al actor que realizara repetidamente las acciones que se le fueran indicando. Una de las principales motivaciones de este proceso es facilitar un conjunto de datos que pueda ser posteriormente empleado para el entrenamiento del sistema. Como resultado se obtuvieron dos paquetes de vídeos por cada actor capturados mediante el módulo de captura de imágenes. Estos paquetes están compuestos por tres tipos de vídeos cada uno: Vídeo RGB, vídeo de profundidad y vídeo de esqueleto. Posteriormente cada una de estas secuencias grabadas tuvieron que ser manualmente segmentadas y etiquetadas por acciones (véase § 6.4.2.2) mediante la herramienta elaborada en el presente proyecto (véase § 6.5). Recuérdese que la segmentación automática de vídeos en acciones independientes queda fuera del alcance y objetivos de este proyecto. Los lectores interesados en la segmentación automática de vídeos puede referirse a [RA00] [con97] [AA01] [SMS07] y [SWCS08]. Por último es importante destacar que, como los vídeos de las personas pueden considerarse datos de carácter personal, fue necesario la elaboración de un formulario de consentimiento (véase § C). De esta forma, antes de comenzar con el proceso de grabación los actores debían leer un documento que les era facilitado. En este documento se explicaba el objetivo del proyecto, el uso de dicha grabación, etc. Además se les facilitaba respuesta a todas las preguntas que les pudiere surgir acerca del documento o del proceso. Finalmente se les proporcionaba un formulario que debían rellenar y firmar si estaban de acuerdo con el contrato. Para asegurar la confidencialidad, el único momento en el que quedan relacionados lo vídeos con los datos identificativos de los actores (nombres y apellidos) es en dicho formulario. De este modo, los vídeos fueron nombrados como actor1, actor2, etc. Finalmente estos formularios fueron almacenadas en el grupo ARCO, lugar de acceso restringido, para asegurar su seguridad. 7.3 Análisis de los resultados Una vez que el dataset KinbehrDataset ha sido generado, segmentado y etiquetado por acciones, es el momento de realizar el análisis de los resultados obtenidos. No obstante, antes es necesario aclarar algunos conceptos importantes que se mencionaron anteriormente. Estos son los valores de algunos de los parámetros empleados por las herramientas stipdept (véase § 6.4.2.3.1) y bsvm-train (véase § 6.4.2.3.3). Como a priori no se conoce cuál es el valor más adecuado para el caso de estudio, se realizaron diferentes pruebas tomando diferentes valores. De este modo, se pudo determinar qué valores eran los más adecuados para estos parámetros y así poder obtener los mejores resultados posibles. 171 A continuación se expone el análisis dichos resultados. Estos muestran el porcentaje de acierto de cada actor según tipo de acción clasificados por la clase de vídeo (RGB, profundidad y esqueleto). En el Cuadro 7.2 se muestra el análisis de resultados correspondientes a los vídeos obtenidos en el proceso de grabación no guiado y en el Cuadro 7.3 los correspondientes a los vídeos obtenidos en el proceso de grabación guiado. Es importante mencionar que los guiones representan que el actor correspondiente no ha realizado una determinada acción. Por último, también se muestra el porcentaje total de acierto del actor para todas las acciones que ha realizado. En el Cuadro 7.4 se muestra un resumen del análisis de los resultados obtenidos según el tipo de acción. Estos resultados representan el porcentaje de acierto clasificados por la clase de vídeo (RGB, profundidad y esqueleto). En la Figura 7.3 se muestra un gráfico que representa el porcentaje de acierto según la clase de vídeo para cada acción, considerando los vídeos grabados en el entorno guiado y no guiado. Figura 7.3: Porcentaje de acierto de cada acción según el tipo de imagen (entorno guiado y sin guiar). En el Cuadro 7.5, el Cuadro 7.6 y el Cuadro 7.7 se muestran las matrices de confusión correspondientes a cada tipo de vídeo, RGB, profundidad y esqueleto respectivamente. En el campo de la inteligencia artificial una matriz de confusión es una herramienta de visualización que se emplea en aprendizaje supervisado. Cada columna de la matriz representa el número de predicciones de cada clase, mientras que cada fila representa a las instancias en la clase real. Uno de los beneficios de las matrices de confusión es que facilitan ver si el sistema está confundiendo dos clases. No obstante, es importante tener en cuenta que si en este tipo de matrices el número de muestras de clases diferentes cambia mucho la tasa de error del clasificador no es representativa de lo bien que realiza la tarea el clasificador. Esto quiere decir que si por ejemplo hay 1000 muestras de la clase 1 y sólo 20 de la clase 2, el clasificador puede tener fácilmente un 172 Actor 1 Actor 2 Actor 3 Actor 4 Actor 5 Actor 6 Actor 7 Actor 8 Actor 9 Actor 10 Actor 11 Actor 12 Actor 13 Actor 14 Actor 15 1 2 3 4 5 6 7 8 9 10 11 12 13 14 Total RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto - 0 - 0 0 0 - 25 25 0 66.6 0 0 50 50 0 33.3 33.3 0 50 0 0 0 0 0 33.3 0 0 0 20 0 0 0 0 33.3 0 66.6 0 0 0 0 0 0 - 50 50 0 66.6 0 50 50 0 0 66.6 33.3 50 33.3 66.6 0 50 25 0 80 60 66.6 20 20 0 50 0 100 0 0 0 100 50 50 0 - 16 0.1 12.5 26.3 0.05 12.5 12.5 0.1 9 17.4 0.1 0 0 0 0 12.5 0.06 0 0 0 0 42.8 0 0 0.1 0 16.7 0 7.7 0 25 6.7 6.6 30 10 10 15 5.5 5.5 14.3 0 0 0 0 0 58 84.2 60 50 50 44.4 31.8 59 33.3 10 70 14.3 100 66.6 100 46.2 46.1 40 50 80 90 25 41.7 40 79.3 89.7 77.8 60 75 75 65 80 75 63.2 68.4 78.9 54.1 75 47.8 38.5 73 61.5 41.6 66.6 41.7 0 0 0 0 0 0 0 0 - 40 40 50 37.5 46.9 43.8 29.4 35.2 12.5 55.7 42.6 50.9 30.3 27.5 21.7 28.6 0.06 7.1 42.8 18.7 10.5 50 25 33.3 50 11.1 11.1 50 0 0 36.2 24.1 20.7 33.3 22.2 22.2 12.5 12.5 12.5 60 40 20 35 20 30 43 60 66.6 20 60 0 50 83.3 66.6 36.1 38.3 29.3 0 33.3 0 0 100 100 100 100 100 22.2 66.6 100 0 100 100 0 0 0 0 36.4 27.3 100 0 100 - 42 41.6 0 75 62.5 42.9 21 26.3 0 15 0 0 14.2 28.6 16.7 50 25 40 26.6 28.6 7.1 60 60 25 100 60 33.3 33.3 33.3 0 0 0 0 50 50 0 50 50 25 33.3 33.3 14.3 33.3 66.6 11.1 0 0 0 0 0 0 0 0 0 0 0 0 50 0 0 50 0 0 11.1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 - 48 43.4 30.5 39.2 32.4 29.2 19.8 25.8 13.9 31.2 27.2 25.5 30.1 27.3 22.2 27.4 17.8 13.6 31.3 28.3 23.3 37.9 24.2 21.9 42.8 39.8 38.6 34.1 36.9 39.1 33.1 27.4 24.7 39.6 39.6 43.4 29.7 33.8 21.1 24.7 35.5 24.7 30.8 26.9 25 Cuadro 7.2: Porcentaje de acierto de cada actor (sin guiar) en cada tipo de actor según el tipo de imagen. 173 1 Acciones 1 Acciones 2 Acciones 3 Acciones 4 Acciones 5 Acciones 6 Acciones 7 Acciones 8 Acciones 9 Acciones 10 Acciones 11 RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 50 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 50 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad 0 Esqueleto 0 RGB 0 Profundidad Esqueleto RGB 50 Profundidad 0 Esqueleto 0 2 3 4 5 6 7 8 9 10 11 12 13 14 Total 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 50 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 100 50 0 100 50 0 0 0 0 0 0 0 0 50 0 50 100 0 30 50 0 0 50 0 50 50 0 50 100 0 100 0 0 50 100 50 50 50 50 100 100 100 100 100 0 0 100 50 50 100 0 100 0 0 50 100 50 50 100 0 50 33.3 0 33.3 0 0 33.3 0 0 33.3 50 0 0 33.3 0 0 25 0 0 100 0 0 0 0 0 33.3 0 0 0 0 0 0 0 0 75 75 75 100 100 100 50 75 100 100 100 100 100 100 100 100 100 100 75 100 100 100 100 100 75 100 75 50 100 100 66.6 100 66.6 0 0 0 0 0 0 0 0 0 50 0 0 0 0 0 50 0 0 0 0 0 0 0 0 0 0 0 50 0 0 0 62.5 75 87.5 42.9 33.3 0 0 0 14.3 30 30 20 0 20 0 55.5 33.3 55.6 25 0 0 33.3 33.3 33.3 71.4 57.1 57.1 25 50 50 28.6 28.6 14.3 50 60 10 50 100 70 10 50 30 66.7 83.3 83.3 33.3 100 66 25 37.5 12.5 75 75 75 0 33.3 66.6 66.6 83.3 66.6 66.6 66.6 50 0 50 50 0 0 0 0 0 50 0 0 50 50 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 33.3 0 0 50 100 0 100 100 20 0 0 0 100 50 50 100 100 0 100 50 50 50 100 0 50 50 0 50 50 0 0 0 0 33.3 0 0 0 0 0 0 0 0 0 0 50 0 0 50 0 0 0 0 0 33.3 0 0 0 50 0 0 0 33.3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 36.9 39.1 30.4 23.7 25.8 29 18.8 22.9 33 40 29.5 29.5 26.5 29.4 26.5 40.4 30.4 23.9 45.5 29 32.2 28.6 25.8 35.5 35 33.3 30.8 33.3 44.4 40.7 21 23.7 18.4 Cuadro 7.3: Porcentaje de acierto de cada actor (guiado) en cada tipo de actor según el tipo de imagen. 174 No ocurrencias Tipo % acierto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB Profundidad Esqueleto RGB 12 0 0 9 0 0 0 0 0 27.8 6.7 18.2 59 28.8 44.7 16.8 10 6 44.8 70.9 64.2 11.5 0 0 37.7 29.7 28 34.5 55 41.9 4.7 0 10.5 41.1 41.2 11.5 3.1 95 Profundidad Esqueleto RGB 1 6.9 0 113 Profundidad Esqueleto 0 0 Mirar reloj 25 Cruzar brazos 22 Rascar cabeza 23 Sentarse 61 Levantarse 61 Darse la vuelta 250 Caminar 361 Saludar 26 Dar puñetazo 453 Dar patada 108 Señalar 21 Coger 175 Lanzar (por encima de la cabeza) Lanzar (por debajo de la cabeza) Cuadro 7.4: Porcentaje de acierto de cada acción según el tipo de imagen (entorno guiado y sin guiar). 175 Cruzar Brazos Rascar cabeza Sentarse Levantarse Darse la vuelta Caminar Saludar Dar puñetazo Dar patada Señalar Coger Lanzar (encima) Lanzar (debajo) Mirar reloj Cruzar brazos Rascar cabeza Sentarse Levantarse Darse la vuelta Caminar Saludar Dar puñetazo Dar patada Señalar Coger Lanzar (encima) Lanzar (debajo) Mirar Reloj sesgo hacia la clase 1. Si el clasificador clasifica todas las muestras como clase 1 su precisión será del 99 %. Esto no significa que sea un buen clasificador, pues tuvo un 100 % de error en la clasificación de las muestras de la clase 2. En este caso en particular puede resultar problemático ya que la acción que contiene mas ocurrencias (acción dar puñetazo con un valor de 453) difiere bastante con respecto la menor (acción señalar con un valor de 21). 0.12 0.00 0.04 0.00 0.00 0.00 0.00 0.00 0.03 0.01 0.00 0.00 0.01 0.03 0.12 0.05 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.10 0.00 0.00 0.04 0.00 0.00 0.00 0.03 0.03 0.00 0.00 0.07 0.00 0.00 0.00 0.01 0.00 0.00 0.12 0.05 0.04 0.28 0.00 0.02 0.01 0.07 0.07 0.08 0.10 0.03 0.02 0.04 0.12 0.23 0.00 0.00 0.61 0.03 0.01 0.00 0.01 0.02 0.10 0.07 0.02 0.04 0.04 0.05 0.04 0.03 0.00 0.17 0.11 0.04 0.04 0.08 0.05 0.04 0.12 0.11 0.00 0.00 0.00 0.00 0.00 0.17 0.54 0.11 0.17 0.10 0.00 0.05 0.11 0.16 0.08 0.09 0.13 0.07 0.05 0.11 0.10 0.15 0.04 0.03 0.14 0.03 0.06 0.07 0.16 0.45 0.35 0.30 0.13 0.18 0.06 0.11 0.38 0.28 0.24 0.20 0.34 0.32 0.04 0.05 0.09 0.07 0.02 0.26 0.14 0.15 0.18 0.33 0.14 0.05 0.23 0.15 0.08 0.00 0.09 0.13 0.00 0.02 0.03 0.04 0.01 0.05 0.10 0.07 0.03 0.03 0.00 0.00 0.00 0.03 0.11 0.00 0.00 0.00 0.00 0.00 0.00 0.41 0.03 0.00 0.12 0.05 0.22 0.07 0.05 0.04 0.00 0.26 0.06 0.02 0.05 0.03 0.02 0.03 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 Cruzar Brazos Rascar cabeza Sentarse Levantarse Darse la vuelta Caminar Saludar Dar puñetazo Dar patada Señalar Coger Lanzar (encima) Lanzar (debajo) Mirar reloj Cruzar brazos Rascar cabeza Sentarse Levantarse Darse la vuelta Caminar Saludar Dar puñetazo Dar patada Señalar Coger Lanzar (encima) Lanzar (debajo) Mirar Reloj Cuadro 7.5: Matriz de confusión de los vídeos RGB (entorno guiado y sin guiar). 0.00 0.00 0.00 0.00 0.02 0.01 0.00 0.00 0.00 0.01 0.00 0.00 0.00 0.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.05 0.00 0.00 0.07 0.00 0.02 0.00 0.00 0.09 0.06 0.00 0.02 0.03 0.06 0.00 0.00 0.00 0.00 0.27 0.02 0.00 0.04 0.03 0.03 0.00 0.05 0.02 0.06 0.00 0.00 0.00 0.02 0.05 0.04 0.04 0.09 0.04 0.04 0.00 0.07 0.02 0.04 0.71 0.83 0.74 0.31 0.16 0.36 0.74 0.35 0.16 0.11 0.79 0.09 0.25 0.19 0.00 0.00 0.00 0.02 0.02 0.09 0.11 0.00 0.05 0.02 0.00 0.00 0.06 0.08 0.00 0.00 0.00 0.02 0.04 0.09 0.01 0.04 0.29 0.14 0.00 0.06 0.18 0.23 0.10 0.11 0.11 0.34 0.05 0.35 0.09 0.35 0.27 0.54 0.21 0.26 0.31 0.28 0.14 0.06 0.11 0.09 0.02 0.02 0.00 0.13 0.03 0.02 0.00 0.06 0.09 0.04 0.00 0.00 0.00 0.09 0.38 0.00 0.00 0.00 0.00 0.00 0.00 0.38 0.02 0.01 0.00 0.00 0.05 0.05 0.00 0.00 0.00 0.00 0.04 0.04 0.00 0.00 0.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 Cuadro 7.6: Matriz de confusión de los vídeos de profundidad (entorno guiado y sin guiar). 176 Mirar Reloj Cruzar Brazos Rascar cabeza Sentarse Levantarse Darse la vuelta Caminar Saludar Dar puñetazo Dar patada Señalar Coger Lanzar (encima) Lanzar (debajo) Mirar reloj Cruzar brazos Rascar cabeza Sentarse Levantarse Darse la vuelta Caminar Saludar Dar puñetazo Dar patada Señalar Coger Lanzar (encima) Lanzar (debajo) 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.01 0.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.05 0.00 0.00 0.16 0.00 0.01 0.00 0.05 0.05 0.04 0.05 0.00 0.06 0.12 0.00 0.00 0.00 0.00 0.45 0.02 0.01 0.00 0.04 0.05 0.00 0.01 0.01 0.05 0.00 0.06 0.00 0.02 0.00 0.05 0.01 0.09 0.04 0.03 0.05 0.03 0.03 0.09 0.55 0.67 0.47 0.20 0.11 0.23 0.64 0.45 0.23 0.17 0.53 0.06 0.21 0.21 0.00 0.06 0.00 0.00 0.00 0.10 0.14 0.05 0.07 0.02 0.00 0.02 0.04 0.03 0.05 0.00 0.00 0.02 0.11 0.12 0.02 0.09 0.29 0.09 0.00 0.10 0.21 0.23 0.32 0.22 0.53 0.45 0.02 0.38 0.17 0.18 0.19 0.43 0.32 0.50 0.32 0.21 0.05 0.00 0.00 0.09 0.04 0.04 0.00 0.05 0.04 0.09 0.05 0.13 0.04 0.03 0.00 0.00 0.00 0.05 0.28 0.00 0.00 0.00 0.01 0.01 0.00 0.12 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.02 0.00 0.05 0.03 0.06 0.00 0.02 0.07 0.04 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 Cuadro 7.7: Matriz de confusión de los vídeos de los esqueletos (entorno guiado y sin guiar). Llegados a este punto es el momento de contrastar y validar los resultados obtenidos y que se han explicado en los párrafos anteriores con sistemas similares cuyo objetivo final es también el reconocimiento de acciones. Para ello se ha tomado como referencia el estudio efectuado por Jesús Martínez Del Rincón, Jean-Christophe Nebel y María Jesús Santofimia Romero: “Common-sense reasoning for human action recognition” [MDRSN13]. En dicho estudio se presenta un nuevo método que aprovecha las capacidades de razonamiento en un sistema de visión por computador dedicado al reconocimiento de la acción humana. Para ello, proponen una metodología dividida en dos etapas. La primera de ellas está basada en los mismos principios que el presente proyecto: Bag of Words (B OW). Una vez que han obtenido los resultados proporcionados en la etapa de aprendizaje basado en el algoritmo máquina, realizan un procesamiento adicional. Este procesamiento consiste en el análisis y corrección de las estimaciones iniciales proporcionadas por B OW mediante un sistema de razonamiento común. En dicho estudio generan su propio dataset (WaRo11) para obtener los resultados mediante una cámara RGB normal. En el Cuadro 7.8 se muestra una tabla comparativa de los resultados obtenidos en dicho estudio con respecto a los obtenidos en el presente proyecto. A continuación se presenta una breve descripción de la tabla para facilitar su comprensión: La primera columna representa que el sistema [MDRSN13] ha sido entrenado con el dataset IXMAS y evaluado con WaRo11. La segunda columna representa que el sistema K IN B EH R ha sido entrenado con el dataset IXMAS y evaluado con KinbehrDataset. La fila representa que se ha empleado únicamente la etapa de B OW. 177 B OW Tra. == IXMAS & Test. == WaRo11 Tra. == IXMAS & Test. == KinbehrDataset RGB: 29.4 RGB: 32.7 Cuadro 7.8: Comparación de resultados con [MDRSN13]. Un aspecto a destacar es que los resultados obtenidos con K IN B EH R son algo mejores con respecto a los obtenidos en [MDRSN13] en la etapa de B OW. Es importante mencionar que los vídeos contenidos en el dataset KinbehrDataset son bastante más complejos de evaluar que WaRo11. Esto se debe principalmente a que los actores en KinbehrDataset se comportan de una forma más natural, como por ejemplo realizar varias acciones al mismo tiempo. Por otro lado, en el Cuadro 7.9 se puede observar que los resultados mejoran cuando el sistema es evaluado con el mismo dataset con el que ha sido entrenado. No obstante, estos resultados no son del todo realistas ya que estas circunstancias no se van a dar en un entorno real en el que sea necesario realizar un reconocimiento de acciones. Otro aspecto a destacar es que los resultados obtenidos cuando se emplea un sistema de razonamiento adicional (segunda y tercera fila donde n es el número de acciones considerado en el sistema de razonamiento) son considerablemente mejores. Por lo tanto, es muy posible que mediante la incorporación de un sistema de razonamiento en K IN B EH R se obtenga una tasa de acierto mejorada. Este aspecto será comentado en más profundidad en el capítulo Conclusiones y trabajo futuro (véase § 8). B OW B OW B OW + AIRS (n = 1) + AIRS (n = 5) Tra. & Test. == IXMAS Tra. == IXMAS & Test. == WaRo11 Tra. == IXMAS & Test. == KinbehrDataset RGB: 63.9 Profundidad: Esqueleto: RGB: RGB: - RGB: 29.4 Profundidad: Esqueleto: RGB: 35.5 RGB: 51.9 RGB: 32.7 Profundidad: 30.8 Esqueleto: 28 RGB: RGB: - Cuadro 7.9: Comparación de resultados con [MDRSN13]. Finalmente, para concluir el capítulo es importante explicar algunos de los motivos por los que la tasa de acierto no es mayor en algunos tipos de acciones. Los factores identificados más importantes son los siguientes: En los vídeos de profundidad capturados se ha comprobado que en ciertas ocasiones el middleware NiTE (véase § 6.3.1) identifica al saco de boxeo como una persona. Esto puede introducir ruido que dificulte la tarea de clasificación ya que como se aprecia en la Figura 7.4 se introducen en la escena elementos que no son personas. Este problema se ve acentuado si el saco de boxeo se encuentra en movimiento. Un problema muy similar al anterior ocurre con los vídeo de esqueleto. En la Figura 7.5 se aprecia como el middleware NiTE identifica el saco de boxeo como una persona y por lo tanto es dibujado su “correspondiente” esqueleto. 178 Figura 7.4: Problema encontrado en vídeos de profundidad. Figura 7.5: Problema encontrado en vídeos de esqueletos. El dataset IXMAS etiqueta ciertas acciones de una manera muy particular permitiendo un margen muy pequeño en algunas acciones de las secuencias de vídeos capturadas. Uno de los ejemplos más llamativos es la “acción sentarse”. En IXMAS esta acción es siempre etiquetada con un actor sentándose en el suelo, mientras que en las pruebas realizadas se ha etiquetado como “sentarse” cuando un actor se sienta en la silla proporcionada en el escenario. 179 Capítulo 8 Conclusiones y trabajo futuro E este capítulo se analiza el trabajo realizado en la elaboración de este proyecto, mostrando en qué grado han sido logrados los objetivos que fueron marcados al comienzo de su desarrollo. También se expondrán diversas propuestas de trabajo futuro que podrían mejorar y extender la funcionalidad del sistema desarrollado. N 8.1 Objetivos alcanzados En esta sección se analizarán los objetivos expuestos en el capítulo de objetivos (véase § 2), mostrando de esta manera la forma en que han sido resueltos así como el nivel de satisfacción que ha sido alcanzado con cada uno de ellos. Es importante comenzar recordando cuál era el objetivo principal del proyecto. Este consistía en el desarrollo de un sistema de reconocimiento de acciones que mediante un algoritmo de “aprendizaje máquina” (machine learning) combinara las imágenes de intensidad y profundidad obtenidas mediante un dispositivo que lo permitiera. También debía disponer de una base de conocimiento que contuviera información de alto nivel sobre diferentes tipos de acciones humanas. Llegados a este punto, es posible decir que este objetivo principal ha sido cubierto en su totalidad mediante el desarrollo de un sistema compuesto de un clasificador de máquina de vectores o Support Vector Machines (SVM) y la adopción del modelo Bag of Words (B OW). En el capítulo anterior (véase § 7) se mostraban los resultados y la precisión lograda con dicho sistema. No obstante, se debe recordar que a parte de este objetivo principal, se plantearon una serie de objetivos más específicos que describían de una forma más concisa lo que se esperaba del sistema propuesto. A continuación se muestra cómo se ha afrontado la realización estos objetivos específicos. Evaluación de mercado. Este objetivo consistía en la realización de un análisis de los diferentes dispositivos Kinect disponibles en el mercado (Kinect for Xbox 360, Kinect for Windows y Kinect de segunda generación). Además, también se pretendía decidir qué dispositivo era el más apropiado para el proyecto en base a la información recopilada. Para ello fue necesario realizar un amplio barrido y filtrado de toda la información que se encontraba disponible en la web, libros, artículos académicos, así como los proyec181 tos existentes que hacen uso de esta tecnología. El principal problema con el que hubo de enfrentarse para la consecución de este objetivo fue que la información se encontraba muy dispersa y, en algunas ocasiones, podía llegar a ser un poco contradictoria. Por último, también es importante destacar que en el momento de decidir qué dispositivo era el más apropiado se encontraron problemas presupuestarios ya que tan sólo se tenía la posibilidad de emplear el modelo Kinect for Xbox 360. Análisis de librerías disponibles. Con este objetivo se pretendía realizar un estudio acerca de las plataformas y/o librerías disponibles para el dispositivo Kinect elegido. También se pretendía identificar y analizar las posibilidades que ofrecían cada una, así como las limitaciones, ventajas y desventajas que presentaban. Para lograr la consecución de este objetivo fue necesario realizar una profunda búsqueda en diferentes medios y sintetizar toda la información encontrada para destacar la información relevante para el estudio. Una vez que toda esta información fue procesada, se decidió que la plataforma más adecuada era O PEN NI. Esto se debía principalmente a su naturaleza multiplataforma y software abierto. También es importante destacar que el hecho de permitir la incorporación de diferentes middleware la convertía en una opción mucho más atractiva. No obstante, el principal contratiempo encontrado fue que durante la elaboración del proyecto la compañía creadora de la librería fue comprada y se detuvieron todos los servicios de soporte que se ofrecían hasta el momento. Identificación y análisis de los datos recogidos por el dispositivo. Este objetivo, más técnico que los anteriores, consistía en identificar los diferentes tipos de información proporcionados por el modelo de Kinect elegido. Otra tarea a realizar era analizar cómo debían interpretarse estos flujos de información, así como su manera de manipularlos y procesarlos. De este modo, fue necesario familiarizarse con diversos conceptos relacionados con el tratamiento de imágenes. Para obtener las habilidades técnicas necesarias para trabajar con la plataforma O PEN NI y NiTE se empleó una librería de alto nivel (SimpleOpenNI) mucho más sencilla y fácil de manejar. Gracias a la utilización de esta librería se analizaron algunos conceptos importantes, como por ejemplo la forma de interpretar las imágenes de profundidad o las diferencias con respecto a las típicas imágenes RGB. Una vez que esta primera toma de contacto tuvo lugar, se procedió a llevar a cabo la esencia de este objetivo: Desarrollar el módulo de captura de imágenes empleando O PEN NI y NiTE. Aunque este objetivo ha sido alcanzado con éxito, no estuvo falto de problemas y contratiempos que tuvieron que ser resueltos (véase § 6.2 y § 6.3). Algunos de los más destacados fueron el elevado consumo de memoria o la pérdida de frames durante la captura. Identificación y análisis del conjunto de acciones a reconocer. Con este objetivo se pretendía identificar qué acciones podían ser monitorizadas y reconocidas. De este modo fue posible realizar un análisis de los patrones que caracterizan a cada una. Una vez 182 realizado este análisis, se decidió incorporar un nuevo tipo de vídeo, aparte del RGB y profundidad, que consistía en el esqueleto de los usuarios que estuvieran en escena. Este objetivo también permitió conocer aspectos que serían relevantes posteriormente en el análisis e interpretación de los resultados obtenidos en el sistema. Ejemplo de ello es que en algunas ocasiones aisladas reconocía como personas objetos de las escena. Adaptación del modelo Bag of Words. Este objetivo partía de la realización de un estudio que permitiera obtener una visión general acerca del estado del arte sobre las soluciones existentes. De este modo, fue posible identificar, analizar y, lo más importante, comprender todos los conceptos sobre el funcionamiento de un modelo basado en Bag of Words (B OW). También se llevó a cabo la adaptación de la solución proporcionada a las peculiaridades del proyecto. Una vez que todos estos aspectos estaban resueltos, fue posible la elaboración del módulo de reconocimiento de acciones que, junto con el módulo de captura de imágenes, constituiría el núcleo del sistema. Para ello fue necesario obtener diversas habilidades técnicas para la utilización de diferentes herramientas y los conceptos que tenían asociados. Uno de los más importantes fue cómo obtener puntos de interés espacio-temporales de los vídeos obtenidos mediante la herramienta stipdept1 . No obstante, no fue el único reto ya que estos puntos obtenidos debían ser procesados mediante técnicas de clustering. Aunque este objetivo fue completado con éxito, supuso todo un reto. Esto se debió principalmente a que muchos de los conceptos aplicados eran totalmente desconocidos. Desarrollo de un clasificador (SVM). Este objetivo consistía en realizar un estudio, análisis y diseño de las diferentes técnicas de clasificación existentes y que permitan el reconocimiento de patrones de las acciones que se pretender monitorizar. También fue necesario familiarizarse y comprender los conceptos asociados al funcionamiento de este tipo de clasificadores. De este modo, para la consecución de este objetivo se empleó una solución existente proporcionada por la herramienta BSVM 2 . Posteriormente, se llevaron a cabo los procesos de entrenamiento y evaluación del mismo. Este objetivo fue completado con éxito. No obstante, se encontraron nuevamente las mismas dificultades: Algunos los conceptos eran totalmente desconocidos. Organización del conjunto de sujetos del experimento. Con este objetivo se pretendía que mediante la utilización de un método científico de recogida de datos se confeccionara un conjunto de datos (ejemplos de entrenamiento o muestras) de diferentes individuos. En primer lugar es importante destacar que se decidió emplear dos conjunto de datos diferentes para la evaluación del sistema desarrollado. El primero de ellos debía ser un dataset público que permitiera entrenar de forma adecuada al sistema. Para ello se tuvo que realizar un breve estudio sobre los dataset existentes, donde se identificó que 1 2 http://www.di.ens.fr/~laptev/index.html http://www.csie.ntu.edu.tw/~cjlin/bsvm/ 183 los que mejor se adaptaban a las necesidades del proyecto eran INRIA Xmas Motion Acquisition Sequences (IXMAS) [WRB06] y Hollywood [LMSR08]. Tras realizar un análisis en profundidad de ambos, se decidió emplear el dataset IXMAS. Para el segundo de ellos se decidió crear un dataset propio (KinbehrDataset) con vídeos capturados mediante el módulo de captura de imágenes desarrollado. De esta forma, fue necesario preparar un escenario donde los actores pudieran realizar las diferentes acciones mediante la inclusión de un saco de boxeo, una pelota, etc. También es importante mencionar que se decidió realizar dos procesos de grabación bien diferenciados: Guiado y sin guiar. Mientras que en el primero el usuario realizaba las acciones que se le fueran indicando, en el segundo el actor era dejado sólo en la habitación durante ocho minutos con la única instrucción de hacer lo que quisiera. Una vez que ya se tenían todos los vídeos, fue necesario la segmentación y etiquetación de los mismos. El último paso de este objetivo consistió en poner en marcha el sistema con los diferentes dataset y analizar los resultados obtenidos. El objetivo fue logrado con éxito, aunque para ello fue necesario enfrentarse a alguna dificultad. Entre las más destacadas fue el coordinar y organizar a todos los participantes de las grabaciones; la dificultad de realizar una correcta etiquetación de los vídeos o la elaboración de un formulario adecuado que se encontrara en consonancia con la legislación vigente acerca de la protección de datos de carácter personal. Desarrollo de una interfaz gráfica. Este objetivo consistía en el desarrollo de una interfaz gráfica que permitiera integrar los diferentes módulos que habían sido desarrollados durante el proyecto. Para la consecución de este objetivo fue necesario realizar un estudio y análisis de las diferentes soluciones existentes para la implementación de esta interfaz de usuario que permitiera facilitar la utilización a los futuros usuarios del sistema. Debido a que gran parte del proyecto está escrito en el lenguaje de programación C++ y debido a la gran cantidad de funcionalidades que ofrece, Qt3 fue la herramienta elegida para desempeñar esta labor. Tras este breve análisis de los objetivos marcados al comienzo del proyecto y como conclusión final referente a estos objetivos, es posible afirmar que todos han sido alcanzados satisfactoriamente. 8.2 Trabajo futuro La realización del proyecto descrito en la presente memoria ha supuesto la creación de un sistema de reconocimiento de acciones a través de los vídeos RGB y de profundidad capturados por el dispositivo Kinect. No obstante, a pesar de cumplir con todos los objetivos marcados al comienzo del proyecto, es susceptible de diversas mejoras e incorporación de nuevas funcionalidades. A continuación se presenta un breve resumen de estas mejoras que 3 http://qt-project.org/ 184 posiblemente sean abordadas en un Trabajo Fin de Máster. El proceso de clasificación de acciones propuesta en el presente proyecto está centrado en el procesamiento de vídeo. Sin embargo, como ya se mencionaba anteriormente, el middleware NiTE proporciona información bastante precisa sobre la ubicación de las articulaciones de los usuarios que se encuentran en escena. Hasta el momento, esta información sólo ha sido aprovechada para generar un nuevo tipo de secuencias de vídeo: Vídeo de esqueleto. No obstante, al igual que se ha propuesto un clasificador basado en el procesamiento de vídeo, sería posible desarrollar otro clasificador que procesara esta información. Es por ello por lo que se ha querido dejar preparado el módulo de captura de imágenes para la inclusión de esta nueva funcionalidad mediante el almacenamiento de estos datos en ficheros XML (véase § 6.3.2.3). En el análisis de los resultados obtenidos (véase § 7) se mencionaban algunas de las causas por la que en algunas situaciones el nivel de precisión no era mayor. Una de ellas era debido a que la información proporcionada por el algoritmo NiTE daba lugar, en situaciones concretas, a confusión. Se explicaba como ejemplo de esto lo que ocurría en algunas ocasiones con el saco de boxeo empleado en la recogida de datos, donde era reconocido como si fuera una persona. Aunque la licencia bajo la que es distribuida NiTE no permite su modificación, si sería posible desarrollar alguna solución que analizara los datos proporcionados por NiTE y de este modo eliminar este tipo de información incorrecta. En el capítulo de resultados (véase § 7) se anticipaba que, aunque no era objetivo del presente proyecto, el etiquetado y segmentación automática de vídeos podría facilitar en gran medida el trabajo necesario para el funcionamiento de un sistema de reconocimiento de acciones. Es por ello por lo que se considera interesante como mejora al sistema presentado. Entrenar el sistema con datos obtenidos mediante Kinect, lo que mejoraría sensiblemente la tasa de reconocimiento. Como ya se anticipaba en el capítulo de resultados (véase § 7), el nivel de precisión proporcionada por K IN B EH R puede ser mejorado mediante la inclusión de una nueva etapa en el proceso de reconocimiento. Esta etapa consiste en proporcionar al sistema la capacidad de razonar los resultados obtenidos en la etapa de clasificación. De este modo, se podría mejorar considerablemente la tasa de acierto. Un ejemplo muy claro de ello podría ser que si por ejemplo el clasificador identifica una determinada acción como levantarse y el actor no se ha sentado en ningún momento, debería descartar este resultado. Hoy en día los dispositivos móviles incorporan una gran variedad de sensores (acelerómetros, geolocalización, etc.) que proporcionan información de forma continua: 185 Orientación, altura, posición etc. Además, en este último año se están presentando un nuevo tipo de dispositivo que es posible que revolucione este campo y que en próximos años mucha gente podría ir equipado con uno: Los dispositivos “wearables”. Este tipo de información puede resultar muy interesante en la labor de reconocimiento de acciones, proporcionando por ejemplo el ritmo cardiaco de una persona en un instante determinado. Es por este motivo por el que se cree que la incorporación de la información facilitada por estos sensores al sistema puede resultar realmente interesante en la tarea de reconocimiento de acciones. 186 Capítulo 9 Conclusions and future work This chapter describes the accomplished work during this final year project. To this end, the objectives stated at the beginning of this document are listed and checked for verification. Finally, future work are also stated in order to outline future system improvements and functionality extensions. 9.1 Achieved objectives This section analyses those objectives that were stated in chapter 3, therefore showing the way how these have been tackled and achieved. First of all, it is important recall that the main objective of this project was to develop a system for human action recognition. To this end, this project has followed a machine learning approach based on the combination of depth and intensity images used as inputs to the system. This machine learning system should also count on high level information about different types of human actions. At moment in time, it can be said that this objective has been fully achieved through the implementation of a system combining the use of a Support Vector Machines (SVM) and a Bag of Words (B OW) model. Previous chapter shows details about the system performance and accuracy achieved by this implementation. However, it should be noted that apart from the main goal, more specific goals were also stated describing more concrete system results. Next, a description of how these goals have been tackled is provided. Market analysis. This objective was intended to carry out a market analysis about different Kinect devices currently available (Kinect for Xbox 360, Kinect for Windows and Kinect second generation). Moreover, this analysis was also intended to evaluate the more appropriate device considering the project requirements. In order to accomplish this goal, a thorough analysis of the information available in the Internet, books, academic papers, and stated-of-the-art project using this technology was carried out. The main problem that was faced was the information dispersion as well as their lack of accuracy. Finally, it has to be noted that apart from technological issues, budget considerations had to also be considered. Based on these requirements, Kinect for Xbox 360 was finally chosen. 187 Analysis of available libraries. This objective was intended to analyse existing platforms and/or libraries available for the chosen Kinect device. Moreover, this objective also aimed at identifying and analysing the offered functionalites along with their strengths and weaknesses. Based on the information retrieved from this study, O PEN NI was chosen. The main reasons grounding this selection are that O PEN NI is multiplatform and open source. Also, O PEN NI supports the integration for different middleware systems. In this sense, the main obstacle that had to be overcome was the fact that the company providing the library was bought and discontinue the support services. Identification and analysis of the device collected data. This objective was intended to carry out a more technical work consisting in the identification of the different types of information provided by Kinect. An additional task was to analyse how the different information flows had to be interpreted, manipulated and processed. This task involved acquiring a solid background for image manipulation. SimpleOpenNI was used to simplify how O PEN NI and NiTE were used. This library was an excellent tool to start working with new concepts such as RGB or O PEN NI and NiTE depth images. Afterwards, the module for image capture using O PEN NI and NiTE was developed. Despite having fulfilled this goal, some troubles were experienced though successfully handled (please refer to § 6.2 and § 6.3). Among the most important ones we can mention the high memory usage or frame lost during image recording. Identification and analysis of the set of actions to be considered. This objective was intended to identify the actions that were going to be monitored and therefore recognised. After having carried out this analysis we decided to include a new type of video recordings, apart from the RGB and depth ones, as it was the actor skeleton recordings. This object was also an enabling one for later stages such as the system result analysis and interpretation. For example, we realised that some objects in the scene were considered as humans by our system. Adapting the Bag of Words Model. This objective started from the analysis of the stateof-the-art for recognising systems intended to select the most appropriate one in terms of efficiency and accuracy. Therefore, Bag of Words (B OW) model was selected and implemented in our system taking into account the feature of the project. Once these issues were handled, a module for action recognition was developed, along with an additional module for image capture. Different skills and tools were used to this end, among the most important ones we can highlight obtaining the spatio-temporal points of interest of videos using the stipdept1 . However, this was not the only challenge since a clustering process has to be undertaken afterwards. An (SVM) classifier development. This objective involves the study, analysis, and final implementation of one of the available classification techniques. This module implements 1 http://www.di.ens.fr/~laptev/index.html 188 a pattern recognition approach to support the human action monitoring and recognition. In order to accomplish this goal several approaches were studied, although BSVM 2 was finally chosen to be implemented. Finally, the system was trained and tested. Selecting and organising the set of experimental subjects. This objective is intended to provide a dataset recorded complying with a scientific methodology in order to be used for testing and evaluation purposes. Recall that different datasets were used for training and testing the system. The training system should meet several requirements such as being a public a basic dataset so that the system could be trained with basic actions. A thorough revision of the state-of-the-art was carried out in order to identify those datasets and select the one complying the system requirements. INRIA Xmas Motion Acquisition Sequences (IXMAS) [WRB06] and Hollywood [LMSR08] datasets were the most appropriate ones, being IXMAS the one chosen for the purpose of training the system. Afterwards, the system evaluation or testing was carried out using a self-designed dataset known as KinbehrDataset recorded using the module implemented in this project for image capture. To this end we had to prepare an appropriate context in which actors could naturally perform the actions the system had been trained with. Also, for future work, actors were also recording performing actions in a guided manner attending to provided commands. On the other hand, the unguided performance of actors were only based on the sole command of being themselves and staying in the room for 8 minutes. After having recorded all the videos, a process of segmentation and labelling was carried out. Finally, the system had to be tested using these videos and accuracy results were collected based on the ground truth information provided during the segmentation and labelling process. Among the main difficulties faced during the accomplishment of the objective we can mention the coordination and organisation of the volunteers participating in this study; also labelling and segmenting videos was tedious although simplified by the supported tool designed during this project. Finally, it has to be highlighted that the video recording task complies with the Spanish Law for personal data protection. Developing a graphical user interface. Due to the fact that different modules were implemented during this project, there was a risk for potential user to find the system difficult to use. In order to face this problem, it was decided to implement a graphical user interface to abstract the user from having to deal with isolated modules. This interface makes transparent the way how potential users can run the different modules as though they were one. Taking into account that most of the project was written in C++, and due to many features of Qt3 we selected this tool for implementing the graphical user interface. 2 3 http://www.csie.ntu.edu.tw/~cjlin/bsvm/ http://qt-project.org/ 189 It can be therefore concluded that all the objectives stated during the early stage of the project have been successfully addressed. 9.2 Future work The project described in this document have consisted in the implementation of a system for human action recognition based on the video analysis of RGB and depth sequences recorded using the Kinect device. However, despite having met all the objectives initially stated for this project, several improvements could be carried out in order to extend the system functionality. A list of some of these suggestions is provided underneath and might be tackled during my Master dissertation. This project has focused on the use of video sequences, however, the NiTE middleware provides a functionality to obtain precise information about the human skeleton. Articulation points are provided by this middleware. Despite having been recorded in the KinbehrDataset this information has not been exploited at all. However, the system is already prepared form capturing these type of images as well as for obtaining the articulation points in an XML file (please refer to § 6.3.2.3). During the evaluation and system analysis presented in the result chapter (please refer to § 7) we have identified several causes that lead to wrong recognition. One of them is due to the fact that several objects are considered to be humans, for instance it was quite common for the boxing bag to be considered as a human whenever it was bouncing. A possible solution to this issue could consists in the analysis of the data provided by the NiTE middleware in order to remove this incorrect information. Please note that modifying the NiTE middleware is not an option since the library license does not permit modifications. During the result chapter (please refer to § 7) we already pointed out that the automatic segmentation and label of videos were totally out of the scope of the project. However, efforts could be dedicated to this task in order to be totally autonomous during the training and recognising stage. So far, the system has been trained with RGB videos. However, it would be desirable to train and test the system using only Kinect videos. As it was foreseen during the result chapters (please refer to § 7) the accuracy level provided by K IN B EH R can be improved by including during the recognising stage an upper supervision layer in which reasoning tasks could be carried out in order to determine whether the recognised action makes sense in the supervised context. For example, if the classifier concludes that the actions taking place are the one of standing up the reasoning system could verify that the actor has previously sat. Finally, the majority of the mobile phones that can be found in the market already 190 include a great variety of sensors (ranging from accelerometers, geolocalizers, etc.). These sensors can be used to enhanced the recognition system. Moreover, wearable devices could also be of a great help in this regard. These devices could provide useful information for action recognition such as cardiac rhythm. Combining information from different sources could improve accuracy rates for action recognition. 191 ANEXOS 193 Anexo A Listados de los ejemplos con Processing A.1 Ejemplo 1 1 2 import SimpleOpenNI .∗; SimpleOpenNI kinect ; 4 5 void setup () { size (640∗2 , 480) ; kinect = new SimpleOpenNI ( this ) ; 6 7 kinect . enableDepth () ; kinect . enableRGB () ; 9 10 11 } 13 14 15 void draw () { kinect . update () ; PImage depthImage = kinect . depthImage () ; PImage rgbImage = kinect . rgbImage () ; 17 18 image ( depthImage , 0 , 0) ; image ( rgbImage , 640 , 0) ; 20 21 22 } 24 25 26 27 void mousePressed () { color c = get ( mouseX , mouseY ) ; println ( " r : " + red ( c ) + " g : " + green ( c ) + " b : " + blue ( c ) ) ; } Listado A.1: «Ejemplo 1» [Bor12] 195 A.2 Ejemplo 2 1 2 import SimpleOpenNI .∗; SimpleOpenNI kinect ; 4 5 void setup () { size (640 , 480) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; } 6 7 8 9 11 12 13 void draw () { kinect . update () ; PImage depthImage = kinect . depthImage () ; image ( depthImage , 0 , 0) ; 15 16 17 } 19 20 21 void mousePressed () { int[] depthValues = kinect . depthMap () ; int clickPosition = mouseX + ( mouseY ∗ 640) ; int millimeters = depthValues [ clickPosition ]; float meters = millimeters /1000; 23 24 26 27 println ( " milimetros :: " + millimeters + " metros : " + meters ) ; } Listado A.2: «Ejemplo 2» [Bor12] 196 A.3 Primer ejemplo de nube de puntos 1 2 3 import processing . opengl .∗; import SimpleOpenNI .∗; SimpleOpenNI kinect ; 5 void setup () { size (1024 , 768 , OPENGL ) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; } 6 7 8 9 11 12 void draw () { background (0) ; 14 kinect . update () ; 16 17 translate ( width /2 , height /2 , −1000); rotateX ( radians (180) ) ; 20 stroke (255) ; 22 23 PVector [] depthPoints = kinect . depthM apReal World () ; for(int i = 0; i < depthPoints . length ; i ++) { PVector currentPoint = depthPoints [ i ]; point ( currentPoint .x , currentPoint .y , currentPoint . z ) ; } 24 25 26 27 } Listado A.3: «Primer ejemplo Nube de puntos» [Bor12] 197 A.4 Primer ejemplo de nube de puntos con movimiento 1 2 import processing . opengl .∗; import SimpleOpenNI .∗; 4 SimpleOpenNI kinect ; 7 float rotation = 0; 12 13 void setup () { size (1024 , 768 , OPENGL ) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; } 15 16 17 void draw () { background (0) ; kinect . update () ; 9 10 11 19 20 translate ( width /2 , height /2 , −1000); rotateX ( radians (180) ) ; 22 translate (0 , 0 , 1000) ; 24 25 rotateY ( radians ( rotation ) ) ; rotation ++; 27 stroke (255) ; 29 PVector [] depthPoints = kinect . depthM apReal World () ; 31 32 33 34 35 for (int i = 0; i < depthPoints . length ; i +=10) { PVector currentPoint = depthPoints [ i ]; point ( currentPoint .x , currentPoint .y , currentPoint . z ) ; } } Listado A.4: «Primer ejemplo Nube de puntos con movimiento» [Bor12] 198 A.5 Primer ejemplo de nube de puntos a color 1 2 import processing . opengl .∗; import SimpleOpenNI .∗; 4 5 SimpleOpenNI kinect ; float rotation = 0; 12 void setup () { size (1024 , 768 , OPENGL ) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; kinect . enableRGB () ; kinect . a l t e r n a t i v e V i e w P o i n t D e p t h T o I m a g e () ; 14 } 16 17 void draw () { background (0) ; kinect . update () ; PImage rgbImage = kinect . rgbImage () ; 7 8 9 10 11 18 19 translate ( width /2 , height /2 , −250); rotateX ( radians (180) ) ; translate (0 , 0 , 1000) ; rotateY ( radians ( rotation ) ) ; rotation ++; 21 22 23 24 25 PVector [] depthPoints = kinect . depthM apReal World () ; for (int i = 0; i < depthPoints . length ; i +=1) { PVector currentPoint = depthPoints [ i ]; stroke ( rgbImage . pixels [ i ]) ; point ( currentPoint .x , currentPoint .y , currentPoint . z ) ; } 27 28 29 30 31 32 33 } Listado A.5: «Primer ejemplo Nube de puntos a color» [Bor12] 199 A.6 Dibujando con Kinect 1 2 import SimpleOpenNI .∗; SimpleOpenNI kinect ; 4 5 6 int closestValue ; int closestX ; int closestY ; 8 float lastX ; float lastY ; 9 15 void setup () { size (640 , 480) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; 17 18 } 11 12 13 14 20 21 22 background (0) ; void draw () { closestValue = 8000; 24 kinect . update () ; 26 int[] depthValues = kinect . depthMap () ; 28 29 for(int y = 0; y < 480; y ++) { for(int x = 0; x < 640; x ++) { 31 int reversedX = 640−x−1; 33 34 int i = reversedX + y ∗ 640; int cur rentDe pthVal ue = depthValues [ i ]; 36 if( curre ntDept hValue > 610 && curr entDep thVal ue < 1525 && cur rentDe pthVal ue < closestValue ) { closestValue = c urrent DepthV alue ; closestX = x ; closestY = y ; 38 39 40 41 42 43 } } } 45 46 float interpolatedX = lerp ( lastX , closestX , 0.3 f ) ; float interpolatedY = lerp ( lastY , closestY , 0.3 f ) ; 48 stroke (255 ,0 ,0) ; 50 strokeWeight (3) ; 52 53 54 line ( lastX , lastY , interpolatedX , interpolatedY ) ; lastX = interpolatedX ; lastY = interpolatedY ; 200 56 } 58 59 60 void mousePressed () { save ( " drawing . png " ) ; background (0) ; } 61 Listado A.6: «Dibujando con Kinect» [Bor12] 201 A.7 Álbum de fotos 1 2 import SimpleOpenNI .∗; SimpleOpenNI kinect ; 4 5 6 int closestValue ; int closestX ; int closestY ; 8 9 float lastX ; float lastY ; 11 12 13 14 15 17 18 19 20 21 23 24 25 26 27 29 30 31 32 34 35 36 37 38 float image1X ; float image1Y ; float image1scale ; int image1width = 100; int image1height = 100; float image2X ; float image2Y ; float image2scale ; int image2width = 100; int image2height = 100; float image3X ; float image3Y ; float image3scale ; int image3width = 100; int image3height = 100; int currentImage = 1; PImage image1 ; PImage image2 ; PImage image3 ; void setup () { size (640∗2 , 480) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; image1 = loadImage ( " image1 . jpg " ) ; image2 = loadImage ( " image2 . jpg " ) ; image3 = loadImage ( " image3 . jpg " ) ; 40 41 42 43 } 45 46 void draw () { background (0) ; 48 closestValue = 8000; 50 kinect . update () ; 52 int[] depthValues = kinect . depthMap () ; 54 for(int y = 0; y < 480; y ++) { for(int x = 0; x < 640; x ++) { 55 202 56 57 58 int reversedX = 640−x−1; int i = reversedX + y ∗ 640; int cur rentDe pthVal ue = depthValues [ i ]; 60 if( curre ntDept hValue > 610 && curr entDep thVal ue < 1525 && cur rentDe pthVal ue < closestValue ) { closestValue = c urrent Depth Value ; closestX = x ; closestY = y ; } 61 62 63 64 65 66 } 68 69 float interpolatedX = lerp ( lastX , closestX , 0.3) ; float interpolatedY = lerp ( lastY , closestY , 0.3) ; 71 72 switch( currentImage ) { case 1: image1X = interpolatedX ; image1Y = interpolatedY ; } 73 74 image1scale = map ( closestValue , 610 ,1525 , 0 , 4) ; break; case 2: image2X = interpolatedX ; image2Y = interpolatedY ; image2scale = map ( closestValue , 610 ,1525 , 0 , 4) ; break; case 3: image3X = interpolatedX ; image3Y = interpolatedY ; image3scale = map ( closestValue , 610 ,1525 , 0 , 4) ; break; 76 77 78 79 80 81 82 83 84 85 86 87 88 } image ( image1 , image1X , image1Y , image1width ∗ image1scale , image1height ∗ image1scale ) ; image ( image2 , image2X , image2Y , image2width ∗ image2scale , image2height ∗ image2scale ) ; image ( image3 , image3X , image3Y , image3width ∗ image3scale , image3height ∗ image3scale ) ; 90 91 92 lastX = interpolatedX ; lastY = interpolatedY ; 94 95 97 98 100 101 102 103 104 105 106 image ( kinect . depthImage () , 640 , 0) ; } void mousePressed () { currentImage ++; if( currentImage > 3) { currentImage = 1; } println ( currentImage ) ; } Listado A.7: «Álbum de fotos» [Bor12] 203 A.8 Batería musical 1 2 3 4 5 6 7 8 9 12 13 14 15 16 17 class Hotpoint { PVector center ; color fillColor ; color strokeColor ; int size ; int pointsIncluded ; int maxPoints ; boolean wasJustHit ; int threshold ; Hotpoint (float centerX , float centerY , float centerZ , int boxSize ) { center = new PVector ( centerX , centerY , centerZ ) ; size = boxSize ; pointsIncluded = 0; maxPoints = 1000; threshold = 0; fillColor = strokeColor = color ( random (255) , random (255) , random (255) ) ; 19 20 } 22 23 24 void setThreshold ( int newThreshold ) { threshold = newThreshold ; } 26 27 28 void setMaxPoints (int newMaxPoints ) { maxPoints = newMaxPoints ; } 30 31 32 void setColor (float red , float blue , float green ) { fillColor = strokeColor = color ( red , blue , green ) ; } 34 35 boolean check ( PVector point ) { boolean result = false ; if ( point . x > center . x − size /2 && point . x < center . x + size /2) { if ( point . y > center . y − size /2 && point . y < center . y + size /2) { if ( point . z > center . z − size /2 && point . z < center . z + size /2) { result = true ; pointsIncluded ++; } } } 37 38 39 40 41 42 43 44 return result ; 46 47 } 49 50 51 void draw () { pushMatrix () ; translate ( center .x , center .y , center . z ) ; 204 fill ( red ( fillColor ) , blue ( fillColor ) , green ( fillColor ) , 255 ∗ percentIncluded () ) ; stroke ( red ( strokeColor ) , blue ( strokeColor ) , green ( strokeColor ) , 255) ; box ( size ) ; popMatrix () ; 53 54 55 56 57 } 59 60 61 float percentIncluded () { return map ( pointsIncluded , 0 , maxPoints , 0 , 1) ; } 64 65 66 boolean currentlyHit () { return ( pointsIncluded > threshold ) ; } 69 70 71 boolean isHit () { return currentlyHit () && ! wasJustHit ; } 73 74 void clear () { wasJustHit = currentlyHit () ; pointsIncluded = 0; } 75 76 77 } Listado A.8: Clase Hotpoint de la aplicación «Batería musical» [Bor12] 2 3 import processing . opengl .∗; import SimpleOpenNI .∗; import ddf . minim .∗; 5 SimpleOpenNI kinect ; 7 float rotation = 0; 1 9 10 11 Minim minim ; AudioPlayer kick ; AudioPlayer snare ; 13 14 Hotpoint snareTrigger ; Hotpoint kickTrigger ; 16 float s = 1; 18 void setup () { size (1024 , 768 , OPENGL ) ; kinect = new SimpleOpenNI ( this ) ; kinect . enableDepth () ; 19 20 21 25 minim = new Minim ( this ) ; snare = minim . loadFile ( " hat . wav " ) ; kick = minim . loadFile ( " kick . wav " ) ; 27 snareTrigger = new Hotpoint (200 , −400, 700 , 250) ; 23 24 205 kickTrigger = new Hotpoint (−200, −400, 700 , 250) ; 28 30 } 32 33 void draw () { background (0) ; kinect . update () ; 34 36 37 translate ( width /2 , height /2 , −1000); rotateX ( radians (180) ) ; 39 40 translate (0 , 0 , 1400) ; rotateY ( radians ( map ( mouseX , 0 , width , −180, 180) ) ) ; 42 43 translate (0 , 0 , s ∗ −1000) ; scale ( s ) ; 46 stroke (255) ; 48 PVector [] depthPoints = kinect . depthM apReal World () ; 50 51 for (int i = 0; i < depthPoints . length ; i +=10) { PVector currentPoint = depthPoints [ i ]; snareTrigger . check ( currentPoint ) ; kickTrigger . check ( currentPoint ) ; 53 54 point ( currentPoint .x , currentPoint .y , currentPoint . z ) ; 56 57 } 59 println ( snareTrigger . pointsIncluded ) ; 61 62 63 if( snareTrigger . isHit () ) { snare . play () ; } 65 66 67 68 if(! snare . isPlaying () ) { snare . rewind () ; snare . pause () ; } 70 71 72 if ( kickTrigger . isHit () ) { kick . play () ; } 74 75 76 77 if(! kick . isPlaying () ) { kick . rewind () ; kick . pause () ; } 79 80 snareTrigger . draw () ; snareTrigger . clear () ; 82 83 84 kickTrigger . draw () ; kickTrigger . clear () ; } 206 86 87 88 89 void stop () { kick . close () ; snare . close () ; minim . stop () ; super . stop () ; 91 92 93 95 96 97 98 99 100 101 102 } void keyPressed () { if ( keyCode == 38) { s = s + 0.01; } if ( keyCode == 40) { s = s − 0.01; } } Listado A.9: Clase principal de la aplicación «Batería musical» [Bor12] 207 Anexo B Módulo de captura de imágenes B.1 Diseño definitivo B.1.1 Modelo de clases definitivo Figura B.1: Diagrama de clases. 209 B.1.2 Estructura de directorio definitivo Figura B.2: Estructura de directorios. 210 B.1.3 Modelo de flujo de la ejecución Figura B.3: Modelo de flujo de la ejecución concurrente. 211 Anexo C Formulario de consentimiento En el siguiente anexo se presenta el formulario de consentimiento que fue empleado para recoger el consentimiento de los actores en la realización de la recogida de datos, que posteriormente fueron utilizados para efectuar las pruebas del sistema desarrollado (véase § 7). Se encuentra dividido en dos partes: Información acerca del estudio y condiciones que se estarían aceptando al dar el consentimiento. • Información general. • Sobre el estudio. Formulario de aceptación. 213 Escuela Superior de Informática de Ciudad Real ÉTICA DE LA INVESTIGACIÓN: FORMULARIO DE CONSENTIMIENTO DE LA MUESTRA Título del Proyecto: KinBehR (KINect for human BEHaviour Recognition) Nombre del investigador: Rubén Cantarero Navarro. Dirección de contacto del investigador: [email protected] Nombre del director del proyecto: María José Santofimia Romero. Dirección de contacto del director del proyecto: [email protected] SECCIÓN I: Información general 1. Le estamos pidiendo que participe en un estudio. 2. Usted no tiene que participar en el estudio. 3. Si dice que sí, puede dejar de participar en el estudio en cualquier momento. 4. Por favor tome todo el tiempo que necesite para decidir. SECCIÓN II: Sobre el estudio 1. ¿Para qué firma este documento?: Lo firma para poder participar en el estudio. 2. ¿Por qué se está haciendo este estudio de investigación?. Se trata de un estudio de investigación que pretende desarrollar un sistema que combine el análisis de imágenes de intensidad y profundidad con una base de conocimiento donde se contenga información de alto nivel sobre acciones humanas. Para ello, será necesario generar un dataset en el que se pueda asegurar que las personas están realizando las acciones con las que se ha entrenado el sistema pero de una manera racional, es decir, motivada con un objetivo concreto. Por lo tanto, también será objetivo de este proyecto la generación de dicho dataset a partir de la grabación y etiquetado de escenarios concretos, donde se realice al menos un número relevante de las acciones con las que el sistema haya sido entrenado. Dichas acciones dependerán de las acciones disponibles en los datasets públicos ya que, utilizando un dataset para entrenar el sistema distinto del utilizado para su evaluación, se asegurará la validez del sistema propuesto. 3. ¿Qué pasa si digo “sí, quiero participar en el estudio”?. si dice que sí: a) Realizaremos una grabación de vídeo mediante un dispositivo Kinect. b) Le daremos un formulario con preguntas para que usted conteste. c) Si quiere, podemos leerle las preguntas en voz alta y escribir sus respuestas en el formulario. d) Estas preguntas no tienen respuestas correctas o incorrectas. Puede saltar cualquier pregunta si no quiere contestarla. 4. ¿Cuánto tiempo tomará el estudio?. El estudio tomará alrededor de veinte minutos de su Escuela Superior de Informática de Ciudad Real tiempo. 5. ¿Qué pasa si digo “no quiero participar en el estudio”?. Nadie le tratará de manera diferente. A usted no se le penalizará. Aunque no recibirá el beneficio de estar en el estudio, no perderá otro beneficio. 6. ¿Qué pasa si digo que sí, pero cambio de opinión más tarde?. Usted puede dejar de participar en el estudio en cualquier momento. A usted no se le penalizará. Aunque no recibirá el beneficio de estar en el estudio, no perderá otro beneficio. 7. ¿Quién verá mis respuestas?. Las únicas personas autorizadas para ver sus respuestas son las que trabajan en el estudio y las que se aseguran de que éste se realice de ,manera correcta. Sus respuestas a la encuesta, su información, y una copia firmada de este documento se mantendrá bajo llave en nuestros archivos. Cuando compartamos los resultados del estudio, no incluiremos su nombre. Haremos todo lo posible para que nadie fuera del estudio sepa que usted participó en él. 8. ¿Quién verá mis grabaciones de vídeo?. Las únicas personas autorizadas para ver sus grabaciones de vídeo son las que trabajan en el estudio y las que se aseguran de que éste se realice de ,manera correcta. Estos ficheros se mantendrán bajo llave en nuestros archivos. Cuando compartamos los resultados del estudio, no incluiremos su nombre. Haremos todo lo posible para que nadie fuera del estudio sepa que usted participó en él. 9. ¿Cómo se usará y compartirá esta información?. a) Usaremos su información y su grabación sólo para el estudio que se describe en este documento. b) Podemos compartir su malformación con otros miembros de la comunidad investigadora. c) Haremos todo lo posible para asegurarnos de que su información permanmezca privada. Sin embargo, si compartimos información con personas que no estén obligadas a cumplir con la Regla de Privacidad, la información dejará de estar protegida por esta Regla de Privacidad. Díganos si tiene alguna duda al respecto. 10. ¿Por cuanto tiempo se usará mi información y mi grabación?. Durante la duración del proyecto. No usaremos ni compartiremos su información una vez terminado el estudio. 11.¿Me costará algo participar en el estudio?. No. 12. Participar en el estudio, ¿me ayudará de alguna manera?. Participar en este estudio no le ayudará, pero podría ayudar al desarrollo y avance en el I+D+I. 13. 14. ¿Me pagarán por mi tiempo?. No. ¿Qué debo hacer si tengo preguntas?. Por favor, contacte con los miembros del proyecto, sí: a) Tiene alguna pregunta sobre el estudio. b) Tiene preguntas sobre sus derechos. c) Cree que se ha lesionado de alguna manera por participar en este estudio. Escuela Superior de Informática de Ciudad Real 15. ¿Se hacen cargo los miembros del proyecto en caso de que me produzca algún daño?. No. 16. ¿Tengo que firmar este documento?. No. Fírmelo solamente si desea participar en el estudio. 17. ¿Qué debo hacer si quiero participar en el estudio?. Tiene que firmar este documento. Le entregaremos una copia. Al participar en este documento esta diciendo que: a) Está de acuerdo con participar en el estudio. b) Le hemos explicado la información que contiene este documento y hemos contestado todas sus preguntas. Escuela Superior de Informática de Ciudad Real ÉTICA DE LA INVESTIGACIÓN: FORMULARIO DE CONSENTIMIENTO DE LA MUESTRA Título del Proyecto: KinBehR (KINect for human BEHaviour Recognition) Nombre del investigador: Rubén Cantarero Navarro. Dirección de contacto del investigador: [email protected] Nombre del director del proyecto: María José Santofimia Romero. Dirección de contacto del director del proyecto: [email protected] A cumplimentar por el participante 1. Sexo: Hombre / Mujer 2. Edad: …...... 3. Altura: …..... 4. Peso: …..... Condiciones de aceptación a) Confirmo que he leído y entendido la hoja de información para el estudio anterior y he tenido la oportunidad de hacer preguntas. b) Entiendo que mi participación es voluntaria y que soy libre de retirarme en cualquier momento, sin dar razón. c) Estoy de acuerdo en participar en el estudio anterior. d) Estoy de acuerdo en que la entrevista este siendo grabada en vídeo. e) Estoy de acuerdo en el uso de comillas anónimas en las publicaciones Escuela Superior de Informática de Ciudad Real A cumplimentar por el investigador 1. Nombre de actor: ................................................................................................................................... 2. Hora de comienzo de la grabación: …................................................................................................. 3. Hora de finalización de la grabación: ….............................................................................................. 4. ¿El participante lleva gafas durante la grabación?: Sí / No 5. ¿Que ropa lleva el participante durante la prueba?: …..................................................................... ….............................................................................................................................................................. .................................................................................................................................................................. .................................................................................................................................................................. .................................................................................................................................................................. 6. Observaciones: ...................................................................................................................................... ….............................................................................................................................................................. .................................................................................................................................................................. .................................................................................................................................................................. .................................................................................................................................................................. 7. Incidencias: ............................................................................................................................................ ….............................................................................................................................................................. .................................................................................................................................................................. .................................................................................................................................................................. .................................................................................................................................................................. Nombre del Participante Fecha Firma Nombre del Investigador Fecha Firma Anexo D Conclusión personal Con la realización del TFG me ha sido posible afianzar y ampliar muchos de los conocimientos adquiridos durante estos últimos cuatro años. Esto se debe a que, gracias a este proyecto, he tenido una oportunidad inmejorable para poner en práctica una gran parte de los conocimientos aprendidos durante estos años. En mi opinión, esto representa un paso crucial en la formación de un ingeniero, ya que no sólo se pone de manifiesto los conocimientos y habilidades de las que dispone, sino que también tiene la oportunidad de mostrar su capacidad de adquirir nuevos conocimientos para resolver un problema o enfrentarse a las dificultades que puedan surgir durante un proyecto de ciertas dimensiones. Gracias a este proyecto se han adquirido nuevos conocimientos que o bien por la elección de asignaturas o por cualquier otro motivo no se habían adquirido y desarrollado durante la carrera. Entre estos conocimientos cabe destacar el aprendizaje y puesta en práctica de una nueva metodología de desarrollo, con todo lo que esto supone. Además, se han adquirido conocimientos que a la larga serán muy valiosos en mi vida profesional. Ejemplo de ellos pueden ser el aprendizaje del lenguaje C++, PERL, o el trabajar con una disciplina de la informática prácticamente nueva para mi: la visión por computador. Todo esto ha dado lugar a una serie de retos que se han tenido que ir salvando a lo largo del proyecto. Uno de los más duros ha sido enfrentarse a materias totalmente nuevas para mí, donde la mayoría del trabajo realizado consiste en la investigación y aplicación de nuevos métodos para la resolución de problemas que están en pleno auge, como es el reconocimiento de acciones. Otro reto especialmente duro ha sido la elaboración de la presente memoria, ya que es la primera vez que he tenido que afrontar la elaboración de una documentación tan rigurosa donde toda palabra y referencia debe estar justificada. Por último, destacar que con la creación de K IN B EH R no se pretende proporcionar una solución definitiva a un problema tan importante como el reconocimiento de acciones. Simplemente se ha pretendido mostrar una posible forma en la que este complicado problema puede ser solucionado, dando un paso más hacia la solución del problema del reconocimiento de acciones humanas. 219 Referencias [AA01] Anjum Ali y J. K. Aggarwal. Segmentation and Recognition of Continuous Human Activity. En IEEE Workshop on Detection and Recognition of Events in Video, páginas 28–, 2001. [AGO+ 12] Davide Anguita, Alessandro Ghio, Luca Oneto, Xavier Parra, y Jorge L. Reyes-Ortiz. Human Activity Recognition on Smartphones Using a Multiclass Hardware-friendly Support Vector Machine. En Proceedings of the 4th International Conference on Ambient Assisted Living and Home Care, IWAAL’12, páginas 216–223. Springer-Verlag, 2012. [AL08] Mohiuddin Ahmad y Seong-Whan Lee. Human Action Recognition Using Shape and CLG-motion Flow from Multi-view Image Sequences. Pattern Recogn., 41(7):2237–2252, 2008. [ann14] ANN: A Library for Approximate Nearest Neighbor Searching. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.cs.umd.edu/ ~mount/ANN/. [ASRW02] Pekka Abrahamsson, Outi Salo, Jussi Ronkainen, y Juhani Warsta. Agile software development methods - Review and analysis, 2002. [BFB94] J. L. Barron, D. J. Fleet, y S. S. Beauchemin. Performance of Optical Flow Techniques. Int. J. Comput. Vision, 12(1):43–77, 1994. [Bor12] Greg Borenstein. Making Things See: 3D vision with Kinect, Processing, Arduino, and MakerBot. O’Reilly Media, 2012. [bsv14] BSVM. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// www.csie.ntu.edu.tw/~cjlin/bsvm/. [Cat12] David Catuhe. Programming with the Kinect for Windows Software Development Kit. Developer reference. Microsoft Press, 2012. [CDF+ 04] Gabriella Csurka, Christopher R. Dance, Lixin Fan, Jutta Willamowski, y Cédric Bray. Visual categorization with bags of keypoints. En In Workshop on Statistical Learning in Computer Vision, ECCV, páginas 1–22, 2004. 221 [con97] Learning Parameterized Models of Image Motion. En Proceedings of the 1997 Conference on Computer Vision and Pattern Recognition (CVPR ’97), CVPR ’97, páginas 561–567. IEEE Computer Society, 1997. [CSTL02] Nello Cristianini, John Shawe-Taylor, y Huma Lodhi. Latent Semantic Kernels. J. Intell. Inf. Syst., 18(2-3):127–152, 2002. [Dav12] Andrew Davison. Kinect Open Source Programming Secrets : Hacking the Kinect with OpenNI, NITE, and Java: Hacking the Kinect with OpenNI, NITE, and Java. Mcgraw-hill, 2012. [dia14] Apps/Dia - GNOME Wiki! Website, 2014. Última consulta: 17 Marzo 2014. url: https://wiki.gnome.org/Apps/Dia/. [ema14] GENU Operating Sytem. GNU Emacs. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.gnu.org/software/emacs/. [Fal13] Soroush Falahati. OpenNI Cookbook. Packt Publishing, 2013. [FCTL10] Chin-Hsien Fang, Ju-Chin Chen, Chien-Chung Tseng, y Jenn-JierJames Lien. Human Action Recognition Using Spatio-temporal Classification. En Hongbin Zha, Rin-ichiro Taniguchi, y Stephen Maybank, editors, Computer Vision – ACCV 2009, volume 5995 of Lecture Notes in Computer Science, páginas 98–109. Springer Berlin Heidelberg, 2010. [ffm14] FFmpeg. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// www.ffmpeg.org/. [FG87] M. A. Föstner y E. Gülch. A Fast Operator for Detection and Precise Location of Distinct Points, Corners and Centers of Circular Features. En ISPRS Intercommission Workshop, Interlaken, Switzerland, 1987. [FK03] Randima Fernando y Mark J. Kilgard. The Cg Tutorial: The Definitive Guide to Programmable Real-Time Graphics. Addison-Wesley Longman Publishing Co., Inc., 2003. [gcc14] Free Software Foundation. Using GCC: The GNU Compiler Collection, 2010. Website, 2014. Última consulta: 17 Marzo 2014. url: http://gcc. gnu.org/onlinedocs/gcc/. [gim14] GIMP - The GNU Image Manipulation Program. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.gimp.org/. 222 [glu14] GLUT - The OpenGL Utility Toolkit. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.opengl.org/resources/libraries/ glut/. [HL02a] Chih-Wei Hsu y Chih-Jen Lin. A Comparison of Methods for Multiclass Support Vector Machines. Trans. Neur. Netw., 13(2):415–425, 2002. [HL02b] Chih-Wei Hsu y Chih-Jen Lin. A Simple Decomposition Method for Support Vector Machines. Mach. Learn., 46(1-3):291–314, 2002. [HS88] Chris Harris y Mike Stephens. A combined corner and edge detector. En In Proc. of Fourth Alvey Vision Conference, páginas 147–151, 1988. [HVC00] Daniela Hall, Vincent Colin de Verdière, y James L. Crowley. Object Recognition Using Coloured Receptive Fields. En Proceedings of the 6th European Conference on Computer Vision-Part I, ECCV ’00, páginas 164– 177. Springer-Verlag, 2000. [IB98] Michael Isard y Andrew Blake. CONDENSATION&Mdash;Conditional Density Propagation for Visual Tracking. Int. J. Comput. Vision, 29(1):5– 28, 1998. [Jan12] Abhijit Jana. Kinect for Windows SDK Programming Guide. Community experience distilled. Packt Publishing, Limited, 2012. [Joa98a] Thorsten Joachims. Text Categorization with Suport Vector Machines: Learning with Many Relevant Features. En Proceedings of the 10th European Conference on Machine Learning, ECML ’98, páginas 137–142, London, UK, UK, 1998. Springer-Verlag. [Joa98b] Thorsten Joachims. Text Categorization with Support Vector Machines: Learning with Many Relevant Features, 1998. [KB10] Mohamed-Bécha Kaâniche y François Bremond. Gesture Recognition by Learning Local Motion Signatures. En CVPR 2010 : IEEE Conference on Computer Vision and Pattern Recognition, San Franscico, CA, United States, 2010. IEEE Computer Society Press. [KBC+ 12] Jeff Kramer, Nicolas Burrus, Daniel Herrera C., Florian Echtler, y Matt Parker. Hacking the Kinect. Apress, edición 1st, 2012. [KHP11] Sean Kean, Jonathan Hall, y Phoenix Perry. Meet the Kinect: An Introduction to Programming Natural User Interfaces. Apressus Series. Apress, 2011. 223 [Kil96] Mark J. Kilgard. OpenGL Programming for the X Window System. Addison Wesley Longman Publishing Co., Inc., 1996. [KJG+ 11] H. Kuehne, H. Jhuang, E. Garrote, T. Poggio, y T. Serre. HMDB: A Large Video Database for Human Motion Recognition. En Proceedings of the 2011 International Conference on Computer Vision, ICCV ’11, páginas 2556–2563. IEEE Computer Society, 2011. [KMN+ 02] Tapas Kanungo, David M. Mount, Nathan S. Netanyahu, Christine D. Piatko, Ruth Silverman, y Angela Y. Wu. An Efficient k-Means Clustering Algorithm: Analysis and Implementation. IEEE Trans. Pattern Anal. Mach. Intell., 24(7):881–892, 2002. [Lap05] Ivan Laptev. On Space-Time Interest Points. Int. J. Comput. Vision, 64(23):107–123, 2005. [LAS08] Jingen Liu, Saad Ali, y Mubarak Shah. Recognizing human actions using multiple features. 2013 IEEE Conference on Computer Vision and Pattern Recognition, 0:1–8, 2008. [LMN10] MichałLewandowski, Dimitrios Makris, y Jean-Christophe Nebel. View and Style-independent Action Manifolds for Human Activity Recognition. En Proceedings of the 11th European Conference on Computer Vision: Part VI, ECCV’10, páginas 547–560. Springer-Verlag, 2010. [LMSR08] Ivan Laptev, Marcin Marszalek, Cordelia Schmid, y Benjamin Rozenfeld. Learning realistic human actions from movies. 2013 IEEE Conference on Computer Vision and Pattern Recognition, 0:1–8, 2008. [Low99] David Lowe. Object Recognition from Local Scale-Invariant Features. En Proceedings of the International Conference on Computer Vision-Volume 2 - Volume 2, ICCV ’99, páginas 1150–. IEEE Computer Society, 1999. [LP07] Ivan Laptev y Patrick Pérez. Retrieving actions in movies. En IEEE 11th International Conference on Computer Vision, ICCV 2007, Rio de Janeiro, Brazil, October 14-20, 2007, páginas 1–8. IEEE, 2007. [LSST+ 02] Huma Lodhi, Craig Saunders, John Shawe-Taylor, Nello Cristianini, y Chris Watkins. Text Classification Using String Kernels. J. Mach. Learn. Res., 2:419–444, 2002. [Mar03] Robert Cecil Martin. Agile Software Development: Principles, Patterns, and Practices. Prentice Hall PTR, 2003. 224 [MCOUHJ+ 09] Francisco Martinez-Contreras, Carlos Orrite-Urunuela, Elias HerreroJaraba, Hossein Ragheb, y Sergio A. Velastin. Recognizing Human Actions Using Silhouette-based HMM. 2013 10th IEEE International Conference on Advanced Video and Signal Based Surveillance, 0:43–48, 2009. [MDD10] Nils Brede Moe, Torgeir Dingsøyr, y Tore Dybå. A Teamwork Model for Understanding an Agile Team: A Case Study of a Scrum Project. Inf. Softw. Technol., 52(5):480–491, 2010. [MDRSN13] Jesús Martínez Del Rincón, Maria J. Santofimia, y Jean-Christophe Nebel. Common-sense Reasoning for Human Action Recognition. Pattern Recogn. Lett., 34(15):1849–1860, 2013. [mer14] Mercurial: Work easier, Work faster, 2014. Website, 2014. Última consulta: 17 Marzo 2014. url: http://mercurial.selenic.com/. [Mil12] Rob Miles. Learn the Kinect API. Microsoft Press Series. Microsoft Press, 2012. [NLT+ 11] Jean-Christophe Nebel, MichałLewandowski, Jérôme Thévenon, Francisco Martínez, y Sergio Velastin. Are Current Monocular Computer Vision Systems for Human Action Recognition Suitable for Visual Surveillance Applications? En Proceedings of the 7th International Conference on Advances in Visual Computing - Volume Part II, ISVC’11, páginas 290–299. Springer-Verlag, 2011. [ope14] OpenCV. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// opencv.org/. [pro14] Processing 2. Website, 2014. Última consulta: 17 Marzo 2014. url: http: //processing.org/. [qt14] Qt Project. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// qt-project.org/. [RA00] Yong Rui y P. Anandan. Segmenting Visual Actions Based on SpatioTemporal Motion Patterns. En CVPR, páginas 1111–1118. IEEE Computer Society, 2000. [SB95] S. m. Smith y J. m. Brady. ASSET-2: Real-Time Motion Segmentation and Shape Tracking. IEEE Trans. Pattern Anal. Mach. Intell., 17(8):814–820, 1995. [SB01] Ken Schwaber y Mike Beedle. Agile Software Development with Scrum. Prentice Hall PTR, edición 1st, 2001. 225 [SB11] Ivan Sipiran y Benjamin Bustos. Harris 3D: A Robust Extension of the Harris Operator for Interest Point Detection on 3D Meshes. Vis. Comput., 27(11):963–976, 2011. [sim14] OpenNI library for Processing. Website, 2014. Última consulta: 17 Marzo 2014. url: http://code.google.com/p/simple-openni/. [SM97] Cordelia Schmid y Roger Mohr. Local Grayvalue Invariants for Image Retrieval. IEEE Trans. Pattern Anal. Mach. Intell., 19(5):530–535, 1997. [SMB00] Cordelia Schmid, Roger Mohr, y Christian Bauckhage. Evaluation of Interest Point Detectors. Int. J. Comput. Vision, 37(2):151–172, 2000. [SMS04] Richard M. Stallman, Roland McGrath, y Paul D. Smith. GNU Make: A Program for Directing Recompilation, for Version 3.81. Free Software Foundation, 2004. [SMS07] Masamichi Shimosaka, Taketoshi Mori, y Tomomasa Sato. Robust Action Recognition and Segmentation with Multi-Task Conditional Random Fields. En ICRA, páginas 3780–3786. IEEE, 2007. [sti14] Space-Time Interest Points. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.di.ens.fr/~laptev/interestpoints.html. [Str00] Bjarne Stroustrup. The C++ Programming Language. Addison-Wesley Longman Publishing Co., Inc., edición 3rd, 2000. [SWCS08] Qinfeng Shi, Li Wang, Li Cheng, y Alexander J. Smola. Discriminative human action segmentation and recognition using semi-Markov model. En CVPR. IEEE Computer Society, 2008. [Tal13] Nicola Louise Cecilia Talbot. Using LaTeX to Write a PhD Thesis. Dickimaw Books, 2013. [TK02] Simon Tong y Daphne Koller. Support Vector Machine Active Learning with Applications to Text Classification. J. Mach. Learn. Res., 2:45–66, 2002. [TV98] Emanuele Trucco y Alessandro Verri. Introductory Techniques for 3-D Computer Vision. Prentice Hall PTR, 1998. [VBC10] Roberto Vezzani, Davide Baltieri, y Rita Cucchiara. HMM Based Action Recognition with Projection Histogram Features. En Proceedings of the 20th International Conference on Recognizing Patterns in Signals, Speech, Images, and Videos, ICPR’10, páginas 286–293. Springer-Verlag, 2010. 226 [WA12] Jarrett Webb y James Ashley. Beginning Kinect Programming with the Microsoft Kinect SDK. Apressus Series. Apress, 2012. [wbI14] IXMAS: 4d-repository :: Public. Website, 2014. Última consulta: 17 Marzo 2014. url: http://4drepository.inrialpes.fr/public/viewgroup/ 6. [WBR07] Daniel Weinland, Edmond Boyer, y Remi Ronfard. Action Recognition from Arbitrary Views using 3D Exemplars. En ICCV 2007 - 11th IEEE International Conference on Computer Vision, páginas 1–7, Rio de Janeiro, Brésil, 2007. IEEE. [wbT14a] TEDCAS: Interfaces de interacción natural para la salud. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.tedcas.com/es. [wbT14b] Teo Park, media artist. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.teopark.com/. [wbU14] Ubi Interactive. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.ubi-interactive.com/. [wbV14] Virtualrehab: Virtual Rehabilitation System. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.virtualrehab.info/es/. [web14a] 3D Mesh Generation with KScan3D software and Kinect. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.kscan3d.com/. [web14b] 3D Virtual fitting dressing room/mirror. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.fitnect.hu. [web14c] Android hardware/software design using virtual prototypes Part 3: Integrating Android’s HAL. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.embedded. com/design/prototyping-and-development/4401419/ Android-hardware-software-design-using-virtual-/ prototypes---Part-3--Integrating-Android-s-HAL. [web14d] ASUS: Xtion PRO. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.asus.com/Multimedia/Xtion PRO/. [web14e] Data Center Software User Manual. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.totalphase.com/support/articles/ 200424386-Data-Center-Software-User-Manual. 227 [web14f] Johnny Lee: Free or cheap Wii Remote hacks. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.ted.com/talks/ johnny lee demos wii remote hacks. [web14g] Jumpido: Educational games for Kinect. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.jumpido.com/en. [web14h] Kinect 3D Hand Tracking. Website, 2014. Última consulta: 17 Marzo 2014. url: http://cvrlcode.ics.forth.gr/handtracking/. [web14i] Kinect Educational App: River Crossing by Kinems. site, 2014. Última consulta: 17 Marzo 2014. http://www.kinecteducation.com/blog/2013/02/12/ kinect-educational-app-river-crossing-by-kinems/. [web14j] Kinect for Windows SDK. Website, 2014. Última consulta: 17 Marzo 2014. url: http://msdn.microsoft.com/en-us/library/hh855347.aspx. [web14k] Kinect for Windows: Voice, Movement and Gesture Recognition Technology. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// www.microsoft.com/en-us/kinectforwindows/. [web14l] Kinect Math: Kinesthetic Learning Experience. Website, 2014. Última consulta: 17 Marzo 2014. url: http://kinectmath.org/. [web14m] kinect-mssdk-openni-bridge: Experimental module to connect Kinect SDK to OpenNI. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// code.google.com/p/kinect-mssdk-openni-bridge/. [web14n] Kinect para Xbox 360. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.xbox.com/es-ES/Kinect. [web14o] KinectEDucation. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.kinecteducation.com/. [web14p] Mando de movimiento PlayStation Move. Website, 2014. Última consulta: 17 Marzo 2014. url: http://es.playstation.com/psmove/. [web14q] Media Lab Students Hack Kinect for Cooler Videoconferencing. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.media.mit.edu/news/external-links/ media-lab-students-hack-kinect-cooler-videoconferencing. 228 Weburl: [web14r] Microsoft Research: Kinect Sign Language Translator expands communication possibilities. Website, 2014. Última consulta: 17 Marzo 2014. url: http://research.microsoft.com/en-us/collaboration/ stories/kinect-sign-language-translator.aspx. [web14s] Minority Report (2002) - IMDb. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.imdb.com/title/tt0181689/. [web14t] Nintendo: Wii. Website, 2014. Última consulta: 17 Marzo 2014. url: https://www.nintendo.es/Wii/Wii-94559.html. [web14u] OpenNI: Open Natural Interaction. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.openni.org/. [web14v] Processing 2: Language Reference (API). Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.processing.org/reference/. [web14w] Project NAVI, a Kinect Hack That Helps Visually Impaired Navigate Indoors. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.medgadget.com/2011/03/ project navi a kinect hack that helps visually impaired/ navigate indoors.html. [web14x] Real-Time Princess Leia Holography Via Kinect Hack. Website, 2014. Última consulta: 17 Marzo 2014. url: http: //www.media.mit.edu/news/external-links/2011/01/ real-time-princess-leia-holography-kinect-hack. [web14y] SigmaNIL. Website, 2014. Última consulta: 17 Marzo 2014. url: http:// www.sigmanil.com/. [web14z] System Development Approaches: Solutionext. Website, 2014. Última consulta: 17 Marzo 2014. url: http://www.solutionext.co.uk/?p=133. [WRB06] Daniel Weinland, Remi Ronfard, y Edmond Boyer. Free Viewpoint Action Recognition Using Motion History Volumes. Comput. Vis. Image Underst., 104(2):249–257, 2006. [WS08] Liang Wang y David Suter. Visual Learning and Recognition of Sequential Data Manifolds with Applications to Human Movement Analysis. Comput. Vis. Image Underst., 110(2):153–172, 2008. [XZSS12] Wenyao Xu, Mi Zhang, Alexander A. Sawchuk, y Majid Sarrafzadeh. Corecognition of Human Activity and Sensor Location via Compressed Sensing in Wearable Body Sensor Networks. En Proceedings of the 2012 Ninth 229 International Conference on Wearable and Implantable Body Sensor Networks, BSN ’12, páginas 124–129. IEEE Computer Society, 2012. [YKS08] Pingkun Yan, Saad M. Khan, y Mubarak Shah. Learning 4D action feature models for arbitrary view action recognition. 2013 IEEE Conference on Computer Vision and Pattern Recognition, 0:1–7, 2008. [ZRZ02] Lei Zhu, Al Bing Rao, y Aldong Zhang. Theory of Keyblock-based Image Retrieval. ACM Trans. Inf. Syst., 20(2):224–257, 2002. 230 Este documento fue editado y tipografiado con LATEX empleando la clase esi-tfg que se puede encontrar en: https://bitbucket.org/arco group/esi-tfg [Respeta esta atribución al autor] 231