Repositorio Institucional de Documentos

Repositorio de la Proyecto Fin de Carrera Reconocimiento visual de juguetes en una mesa de interacción tangible Autor: Director Codirector: la Universidad de Zaragoza – Zaguan http://zaguan.unizar.e Proyecto Fin de Carrera Reconocimiento visual de juguetes en una mesa de interacción tangible Autor: Guillermo Navarro Sánchez Director a: Dra. Sandra Baldassarri Codirector: Dr. Javier Marco Rubio Proyecto Fin de Carrera Ingeniería Informática Diciembre de 2011 http://zaguan.unizar.e s Proyecto Fin de Carrera Reconocimiento visual de juguetes en una mesa de interacción tangible Reconocimiento visual de juguetes en una mesa de interacción tangible 2 Guillermo Navarro Sánchez 3 Proyecto Fin de Carrera Título: Reconocimiento visual de juguetes en una mesa de interacción tangible Autor: Guillermo Navarro Sánchez DNI: 73004926-M Titulación: Ingeniería Informática Directores: Sandra Baldassarri Javier Marco Rubio Departamento: Informática e Ingeniería de Sistemas Centro: Escuela de Ingeniería y Arquitectura Universidad: Universidad de Zaragoza Fecha: 20-Noviembre-2011 Reconocimiento visual de juguetes en una mesa de interacción tangible 4 Guillermo Navarro Sánchez 5 Reconocimiento visual de juguetes en una mesa de interacción tangible Resumen La idea principal de este proyecto fin de carrera (PFC) consiste en conseguir que los niños muy pequeños puedan interactuar con software y elementos informáticos de una manera más natural a través del uso de juguetes convencionales. Para lograr este propósito, este PFC se centró en el estudio y ampliación del framework de reconocimiento visual para dispositivos tabletop, Reactivision. El trabajo se realiza sobre NIKvision, una mesa de interacción tangible especialmente diseñada para su uso por niños pequeños. En primer lugar se ha realizado un estudio de las limitaciones que presenta Reactivision en el reconocimiento de objetos, para posteriormente, realizar varias fases de análisis e implementación de las distintas funcionalidades necesarias para mejorar las limitaciones analizadas. La primera fase consiste en mejorar el reconocimiento de fiduciales, marcadores que adheridos a los juguetes permiten su identificación. Esta fase comprende la creación de una nueva colección de fiduciales que permitan ser acoplados a juguetes pequeños y la posterior implementación de los algoritmos para su reconocimiento. La siguiente fase consiste en la modificación del framework Reactivision para permitir la extracción de características geométricas de los objetos planos (juguetes que no lleven fiduciales en su base) reconocidos de manera que aumenten las posibilidades de los juegos a desarrollar. La tercera fase consiste en la mejora del sistema de comunicación utilizado por Reactivision y los juegos, creando un protocolo de comunicación que permita el envío de volúmenes grandes de datos con estructuras de todo tipo. La última fase consiste en mejorar la interfaz de usuario de Reactivision, incorporando controles que permitan manejar los parámetros de las nuevas funcionalidades implementadas y en modificar los ficheros de configuración de manera que se puedan automatizar las operaciones de inicialización de parámetros. A partir de cada una de las mejoras se han creado varios juegos para comprobar su correcto funcionamiento. Reconocimiento visual de juguetes en una mesa de interacción tangible 6 Guillermo Navarro Sánchez 7 Agradecimientos A Javier y Sandra por sus consejos, conocimiento y paciencia. A Santiago, Tere, Paula y Elvira por su ayuda en la corrección. Reconocimiento visual de juguetes en una mesa de interacción tangible 8 Guillermo Navarro Sánchez 9 Índice general Capítulo 1. Introducción ............................................................................................................................. 11 1.1 Motivación inicial ............................................................................................................................. 11 1.2 Contexto de desarrollo ..................................................................................................................... 12 1.3 Objetivos del proyecto ..................................................................................................................... 14 1.4 Requisitos ......................................................................................................................................... 16 1.5 Estructura de la memoria ................................................................................................................. 17 Capítulo 2. Nueva colección de fiduciales .................................................................................................. 19 2.1 Diseño y detección de nuevos fiduciales .......................................................................................... 19 2.2 Clasificación de áreas ....................................................................................................................... 21 2.3 Identificación de fiduciales ............................................................................................................... 22 2.4 Cálculo de la orientación .................................................................................................................. 25 2.5 Identificación de fiduciales por pantalla .......................................................................................... 26 2.6 Resultados obtenidos ....................................................................................................................... 27 Capítulo 3. Tratamiento de juguetes sin forma definida. .......................................................................... 29 3.1 Diferenciación de objetos................................................................................................................. 29 3.2 Elección de características ............................................................................................................... 31 3.3 Cálculo del área de un juguete ......................................................................................................... 32 3.4 Cálculo de la orientación de un juguete ........................................................................................... 33 3.5 Cálculo del contorno ........................................................................................................................ 35 3.6 Resultados obtenidos ....................................................................................................................... 40 Capítulo 4. Protocolo de comunicación. ................................................................................................... 44 4.1 Definición del protocolo ................................................................................................................... 44 4.2 Usos del protocolo ........................................................................................................................... 45 4.3 Resultados obtenidos ....................................................................................................................... 48 Capítulo 5. Interfaz de usuario. .................................................................................................................. 50 5.1 Interfaz de usuario ........................................................................................................................... 50 5.2 Ficheros de configuración ................................................................................................................ 52 Capítulo 6. Resultados. ............................................................................................................................... 56 6.1 Secuenciador. ................................................................................................................................... 56 6.2 Juego de pintar. ................................................................................................................................ 58 6.3 Bugaboo............................................................................................................................................ 60 6.4 Pruebas reales con niños .................................................................................................................. 61 Reconocimiento visual de juguetes en una mesa de interacción tangible 16 A continuación se definen las necesidades y objetivos específicos de este PFC. 1.4 Requisitos El primer paso para el desarrollo de este PFC consiste en distinguir el tipo de juguetes cuyo reconocimiento es defectuoso o nulo para determinar los distintos problemas que plantean y de esta forma analizar el tipo de algoritmos de visión necesarios para su correcta detección. El siguiente paso y una vez analizadas las características de los juguetes a utilizar y sus limitaciones, se procede a realizar el análisis del sistema (Anexo B) para establecer los algoritmos de visión y protocolos de comunicación concretos cuya implementación permita superar los problemas anteriormente citados. Como metodología a emplear se estudiaron dos posibilidades: OMT (Object Modeling Technique) y UML (Unified Modeling Language). Las dos son metodologías de análisis y diseño orientadas a objetos. Al final se optó por la elección de OMT, debido a que sus diagramas se adecuan más a la solución a desarrollar y se determinó que aportaban una visión más detallada del proceso a seguir en la implementación. A continuación se enumeran los requisitos concretos que se quieren cumplir: • Reconocer juguetes pequeños: se propone el diseño de una colección de nuevos fiduciales cuya configuración topológica sea más sencilla que la actual, de manera que puedan ser detectados e identificados sin problemas por la cámara de Reactivision, cuando sean impresos en tamaños de entre 2 cm y 4 cm de lado. Esta colección de fiduciales no necesita ser demasiado amplia, ya que se pretende utilizar para identificar fichas de juegos sencillos de tipo parchís o damas en los que el número de jugadores es limitado (en el parchís cuatro y en las damas dos jugadores). • Extraer otras características (área, contorno, orientación) de aquellos juguetes que no estén identificados mediante fiducial, partiendo de un análisis visual de los Blobs asociados a estos objetos. Pudiéndose así usar juguetes deformables como plastilina, recortables, etc. Para ello se estudiaran las características geométricas necesarias para poder identificar este tipo de juguetes y se implementarán los algoritmos para su extracción y cálculo. • Estudiar y expandir el protocolo TUIO para poder soportar la nueva información obtenida con los nuevos algoritmos de detección que se implementen. Así como crear un nuevo protocolo de comunicación que permita ampliar el tipo de datos a enviar independientemente de su estructura y tamaño. • Modificar la interfaz de usuario de ReacTIVision para permitir configurar los valores que regulan las nuevas funcionalidades, así como mejorar los ficheros de configuración que permitan cargar y almacenar dichos valores y otros que hasta ahora no se puede. Guillermo Navarro Sánchez 17 Para comprobar el correcto funcionamiento de las mejoras llevadas a cabo, se procederá a su incorporación en varios juegos interactivos que las utilicen en el entorno de NIKvision. 1.5 Estructura de la memoria Esta memoria está dividida en los siguientes capítulos principales: • Capítulo 1. Introducción: Se presentan brevemente la motivación inicial del proyecto, el contexto en el que se enmarca, los objetivos y requisitos que se presentan así como la estructura de la memoria. • Capítulo 2. Nueva colección de fiduciales: Se analiza el diseño de los nuevos fiduciales así como las diferentes alternativas estudiadas para el reconocimiento de juguetes pequeños. A su vez se detallan los algoritmos implementados para su detección y los resultados obtenidos. • Capítulo 3. Tratamiento de juguetes sin forma definida: En este capítulo se explica los problemas y limitaciones que presenta Reactivision en el uso de juguetes deformables y sin forma definida en los que no se puede acoplar fiducial. Se analiza las características que se van a extraer de este tipo de juguetes, porque se han escogido para la identificación de éstos. Por último se detallan los algoritmos implementados para la extracción de estas características y los resultados obtenidos gracias a su cálculo. • Capítulo 4. Protocolo de comunicación: Se explica en qué consiste el protocolo de comunicación diseñado para el envío de la nueva información, así como la estructura de los ficheros XML utilizados. • Capítulo 5. Interfaz de usuario: Este capítulo explica las modificaciones realizadas en la interfaz de usuario de Reactivision así como los ficheros de configuración diseñados para la automatización de las operaciones de inicialización del framework. • Capítulo 6. Resultados: En este capítulo se incluyen los resultados de cada implementación, con ejemplos de su funcionamiento y aplicación en diferentes juegos desarrollados para el tabletop NIKvision. • Capítulo 7. Conclusiones: Se detallan las conclusiones obtenidas a lo largo del PFC se analiza la valoración personal del proyecto y por último se dan posibles ideas para un trabajo futuro. La memoria viene acompañada de los siguientes anexos: • Anexo A. Reactivision y TUIO: Se describe el funcionamiento de Reactivision y TUIO. • Anexo B. Análisis: Se presenta la metodología de análisis y el desarrollo de las clases que forman el framework. Reconocimiento visual de juguetes en una mesa de interacción tangible 18 • Anexo C. Alternativas estudiadas: Se analizan en detalle los distintos algoritmos propuestos para superar cada una de las limitaciones anteriormente citadas y se explican las razones por las que varios de ellos fueron rechazados. • Anexo D. Otros frameworks y tabletops existentes: En este anexo se comentan otros frameworks existentes, realizando una comparación con Reactivision y se analizan algunos tabletops del mercado, comparándolos con NIKvision y las funcionalidades que se han desarrollado en este PFC. • Anexo E. Desarrollo temporal: En este anexo se indica el tiempo empleado en el desarrollo del proyecto en cada una de las fases. Guillermo Navarro Sánchez 19 Capítulo 2. Nueva colección de fiduciales Para que los juguetes puedan ser usados como medio de interacción con juegos de ordenador deben estar marcados con identificadores gráficos. Como se ha explicado anteriormente, los fiduciales que proporciona Reactivision, limitan el tipo de juguetes a utilizar. Por esta razón se ha determinado la necesidad de incorporar nuevos diseños de fiducial para poder adaptarlos a nuevos tipos de juguetes. En este capítulo se analiza el diseño de los nuevos fiduciales y los algoritmos implementados para su detección. En el primer apartado se detalla el diseño del formato de los fiduciales de la nueva colección. En los siguientes apartados se estudian los pasos de los algoritmos seguidos para la identificación de estos fiduciales: 2.1 “Diseño y detección de nuevos fiduciales”, se detalla el diseño del formato de los fiduciales de la nueva colección. 2.2 “Clasificación de áreas, etiquetado de las áreas que forman el fiducial. 2.3 “Identificación de fiduciales, identificación del tipo de fiducial a partir de las características de las áreas obtenidas. 2.4 “Cálculo de la orientación, cálculo de la orientación del fiducial detectado. 2.5 “Identificación de los fiduciales por pantalla”, identificación gráfica del fiducial. 2.6 “Resultados”, se analizan los resultados obtenidos gracias a la detección de nuevos fiduciales. En el anexo C se explica en detalle el estudio previo que se realizó y el análisis de alternativas que finalmente llevaron a la creación de la nueva colección de fiduciales. 2.1 Diseño y detección de nuevos fiduciales El mayor problema que presentaba Reactivision en el reconocimiento de fiduciales pequeños se encontraba en la resolución de la cámara (anexo C). Está era demasiado baja, por lo que detectaba erróneamente las numerosas áreas del fiducial (ver fig. 5). Por tanto se decidió diseñar una nueva colección de fiduciales más sencillos, formados por menos áreas, los cuales gracias a su simpleza no pudiesen dar casos de confusión. Reconocimiento visual de juguetes en una mesa de interacción tangible 20 Figura 5 Imagen a): fiducial real. Imagen b: fiducial detectado por la cámara. La estructura de los nuevos fiduciales, diseñada por ser la más sencilla posible, consiste en un fondo blanco con puntos negros. De esta manera unos fiduciales se distinguirán de otros en función del número de puntos. Teniendo claro el formato de los nuevos fiduciales, se procedió al estudio de posibles algoritmos de detección de agujeros que pudiesen emplearse para identificar el fiducial. En la figura 6 se puede ver un ejemplo de fiducial detectado, el cual se empleará como ejemplo para mostrar las diferentes fases de los algoritmos implementados. Figura 6 Ejemplo de fiducial de la nueva colección El reconocimiento de los nuevos fiduciales se basa en el algoritmo de visión de los fingers de Reactivision. Este realiza una segmentación de la imagen capturada dividiéndola en regiones blancas y negras y tras descartar las regiones que pertenecen a fiduciales se procede a buscar las áreas que tengan un tamaño similar al de los objetos reconocidos como fingers. Este tamaño es establecido a priori por parte del usuario a través de los ficheros de configuración o bien durante la ejecución a través del interfaz de usuario. Una vez detectadas las zonas del tamaño indicado, a través de los algoritmos implementados, se buscan manchas negras sobre el fondo blanco, para comprobar si se trata de un fiducial de la nueva colección o no. Para ello se decide implementar un algoritmo de conectividad entre regiones que permite identificar los agujeros de un objeto y que se detalla a continuación. Guillermo Navarro Sánchez 21 2.2 Clasificación de áreas Una vez detectadas las regiones con el tamaño deseado, se procede a dividirlas en áreas según su color. Para ello en primer lugar se crea una matriz del tamaño de la región detectada, en la que se marca cada celda según el color del pixel que se encuentra en la misma posición en el objeto detectado. De esta manera se tiene una copia del objeto en la matriz y por tanto se puede proceder a distinguir los agujeros del resto de área. En los nuevos fiduciales el fondo está formado por píxeles de color negro igual que los agujeros, mientras que el resto del objeto es de color blanco. En la figura 7 se muestra cómo queda la matriz tras esta primera clasificación. Figura 7 Clasificación de los píxeles (blanco, negro) del objeto detectado. A continuación es necesario etiquetar todas las áreas que forman el objeto y que son de color negro, ya que entre ellas se encuentran las manchas que interesa identificar. Para ello se recorre la matriz por filas y se busca la primera celda que contenga un pixel negro, este pixel será etiquetado con un identificador, por ejemplo '1'. Tras esto, si algún pixel vecino a este es negro, se etiqueta con la misma etiqueta '1'. Lo siguiente será recorrer toda la matriz para encontrar todos los píxeles marcados con la etiqueta '1' y comprobar si sus vecinos también son de color negro, en tal caso serán marcados de la misma forma que su vecino. Una vez finalizado el etiquetado de todos los píxeles vecinos, se vuelve a recorrer la matriz en busca del siguiente pixel negro sin etiquetar y se vuelve a repetir los mismos pasos que se han explicado pero cambiando el nombre de la etiqueta, por ejemplo ‘2’. El algoritmo finalizará cuando todos los píxeles negros hayan sido etiquetados. En la figura 8 se observa un ejemplo de cómo quedaría la matriz tras ser etiquetada y en la que se han detectado 4 áreas distintas. Reconocimiento visual de juguetes en una mesa de interacción tangible 22 Figura 8 Clasificación de las áreas negras del objeto detectado. 2.3 Identificación de fiduciales Una vez etiquetadas las zonas negras que contiene el objeto detectado, el siguiente paso consiste en discriminar las regiones del exterior de la zona blanca, ya que estas no forman parte del fiducial. Para ello se recorre la matriz por filas comprobando todas las áreas etiquetadas. Si estas contienen algún pixel cuya coordenada 'x' o 'y' es igual a la anchura o altura del objeto respectivamente son descartadas, ya que esto indicará que se encuentran por fuera de la zona blanca que forma el fiducial y por tanto no pertenece a este. A continuación se procede al estudio de las áreas negras restantes. Estas pueden ser tanto los agujeros que forman parte del fiducial como áreas causadas por ruido de cámara. Por tanto se deben descartar las producidas por ruido quedándose sólo con los agujeros. Para ello el algoritmo recorre de nuevo la matriz y para cada una de las áreas etiquetadas cuenta el número de píxeles que las forman. Una vez contado el número de píxeles que forman cada área, se escogen las tres de mayor tamaño que pasan a ser las candidatas a ser posibles agujeros del fiducial. Las áreas más pequeñas y por tanto descartadas, corresponden a ruido de cámara, el cual solo está formado por unos pocos píxeles entre 3 y 10, muchos menos píxeles que los agujeros del fiducial. En la figura 9 se muestra un ejemplo ilustrativo de la diferencia entre las áreas que forman los agujeros del fiducial y las áreas que corresponden a ruido de cámara. Guillermo Navarro Sánchez 23 Figura 9 Ejemplo de fiducial detectado con ruido. Los agujeros del fiducial, son notablemente más grandes que el ruido de cámara. No obstante puede ser que alguna de las 3 áreas escogidas, pese a ser de las de mayor tamaño, sea producida por ruido. De darse el caso de que estas 3 áreas correspondiesen solamente con ruido, el algoritmo estaría reconociendo erróneamente ruido de cámara como fiduciales de la nueva colección ya que estaría confundiendo el ruido con agujeros del fiducial. En la figura 10 se puede ver un ejemplo de un posible error de identificación. Para asegurar que se trata de agujeros y no de ruido se comprueba que el número de píxeles que forman estas tres áreas cumplen una serie de restricciones de tamaño. Para que el objeto reconocido sea identificado como fiducial, debe cumplir que el tamaño de sus agujeros esté comprendido entre un 3% y un 60% del área total del objeto. En caso contrario se considera que los agujeros son debidos a ruido y no serán descartados del proceso de búsqueda de agujeros. A continuación se detallan el algoritmo seguido para la clasificación de agujeros: Si: el tamaño de cada uno de los tres agujeros ∈ [3%,60%] del tamaño del área del fiducial entonces Es un fiducial con tres puntos negros sino si: el tamaño de dos de los tres agujeros [3%,60%] del tamaño del área del fiducial entonces Es un fiducial con dos puntos negros sino si: el tamaño de uno de los tres agujeros [3%,60%] del tamaño del área del fiducial entonces Es un fiducial con un punto negro sino El objeto detectado no corresponde con un fiducial de la nueva colección Reconocimiento visual de juguetes en una mesa de interacción tangible 24 Figura 10 Objeto con ruido, en el que las 3 áreas mayores corresponden a ruido. Tras verificar el funcionamiento del algoritmo, se ha identificado que las comprobaciones previamente realizadas (tamaño del fiducial y tamaño de los agujeros) no eran suficientes. Se producían demasiados falsos positivos debido al ruido de cámara, lo que hacía poco preciso el sistema de reconocimiento de los nuevos fiduciales. Al observar el tipo de ruido que producía falsos positivos, se detectó que lo que lo diferenciaba respecto de los fiduciales era el número de áreas que se reconocerían en la clasificación. El ruido que provocaba los errores de reconocimiento estaba formado por un gran número de áreas, es decir, un gran número de agujeros o puntos negros, mientras que los fiduciales reales sólo están formados por unas pocas áreas (los agujeros y algún pixel producido por ruido). En la figura 11 se muestra un ejemplo del tipo de ruido que provocaba falsos positivos. Figura 11 Imagen de una superficie sin objetos en la que solo se ha capturado ruido de cámara. El ruido provoca falsos positivos de fiduciales al estar formado también por una zona blanca con agujeros negros. Guillermo Navarro Sánchez 25 Por tanto se estableció una restricción que consistía en comprobar que el número de áreas detectadas fuese pequeño para que el objeto reconocido fuese considerado como fiducial y no como ruido. El resultado fue una reducción considerable del número de falsos positivos, pero aun así no era suficiente, se seguían produciendo demasiadas falsas identificaciones, lo que hacía poco fiable el sistema de reconocimiento. Tras estudiar de nuevo el ruido de cámara que estaba produciendo los falsos positivos, se identificó que los fiduciales se diferencian de este en la zona blanca que los formaba, es decir, los fiduciales están compuestos por muchos más píxeles blancos que el ruido de cámara detectado. Por tanto se estableció como restricción, que el número de píxeles blancos tuviese que superar un determinado umbral, definido por el usuario, para que el elemento reconocido se considere como un fiducial. Tras volver a probar el sistema de reconocimiento, se dio por válido, pues había reducido casi por completo el número de falsos positivos. 2.4 Cálculo de la orientación Para determinados juegos es interesante disponer de la orientación de los nuevos tipos de fiducial. Se estudió entonces como dotar a los fiduciales de esta característica y se optó por establecer los agujeros en el fiducial de forma que no estuviesen centrados. De esta manera, es posible calcular un vector con origen en los píxeles blancos y final en los píxeles negros, del cual se puede obtener fácilmente la orientación. Para calcular la orientación se procedió a determinar el centro de gravedad de la zona blanca y el centro de gravedad de la zona negra para después hallar la orientación del vector que va desde el centro blanco al centro negro. Para obtener el grado de orientación de vértice se ha utilizado la siguiente fórmula: ( ) ( ) 1 tan( cY _ n cY _ b / cX _ n cX _ b ) orientación =− − Siendo (cX_n, cY_n) y (cX_b, cY_b) las coordenadas de los centros negro y blanco respectivamente. En la figura 12 se observa un fiducial de la nueva detección detectado y los valores de su orientación. Reconocimiento visual de juguetes en una mesa de interacción tangible 32 de rotación y contorno del objeto. A continuación se nombran las diferentes características estudiadas, cuáles fueron finalmente escogidas y la razón de su elección. La orientación ya era extraída en los juguetes con fiducial y para muchos de los juegos que se habían desarrollado era imprescindible el uso de ella. Sirve tanto para saber hacia dónde está mirando el niño con el juguete o para utilizar algún objeto como una ruleta, subir y bajar volumen, etc. Por ello esta fue una de las características escogidas. El área fue otra de las características elegidas, ya que en determinados juegos puede ser importante saber el tamaño del objeto. Por otra parte esta característica permitiría conocer la presión que el niño está haciendo en todo momento algo que podría ser interesante en juegos que requiriesen una información más precisa, como por ejemplo en un juego en el que los niños pintasen con un pincel y dependiendo de la presión el trazo fuese más fino o más grueso. Las características de velocidad, tanto de movimiento como de rotación, finalmente fueron descartadas. Estas características requerirían un manejo de los juguetes con una mayor precisión y los niños pequeños tienen sus habilidades psicomotrices poco desarrolladas, por lo que tras analizarlo se llegó a la conclusión que estas características serían irrelevantes o poco útiles en el desarrollo de juegos para niños tan pequeños. Por último el cálculo de los contornos de los juguetes es interesante y útil. Los juguetes utilizados pueden tener formas muy diversas y no se tiene más información de ellos que su posición. Por ello era preciso disponer de esta característica para poder aprovechar al máximo el juguete utilizado. Por ejemplo se podría detectar el contorno de los juguetes empleados para crear un juego en el que los niños tuviesen que construir murallas de un castillo o colorear el interior de las siluetas de sus juguetes. A continuación se explica en detalle el cálculo de las tres características seleccionadas para su implementación: área, orientación y contorno. 3.3 Cálculo del área de un juguete Para el cálculo del área y la orientación se usa la información que Reactivision proporciona de los objetos sin fiducial. El mecanismo de detección de estos objetos se basa en la misma técnica de detección que los fingers, tras haber segmentado la imagen se procede a la búsqueda de todas las regiones de color blanco que tengan un tamaño similar al establecido en los ficheros de configuración. Una vez detectadas, para cada una de ellas, Reactivision devuelve una matriz en la que se almacena la imagen de cada región, las coordenadas de su posición y la altura y anchura de ésta. Con la altura y la anchura se puede conocer el área rectangular dentro de la que se encuentra el objeto, sin embargo por su estructura irregular, este tipo de juguetes normalmente no ocupará toda esta área. Por tanto aprovechando la matriz devuelta con la imagen de la región y dado que el juguete corresponderá al área de la imagen formada por píxeles blancos, se cuenta el número de píxeles blancos encerrados en el área en la que se encuentra el objeto. De esta manera se obtiene el área de un juguete sin fiducial de una forma precisa. La fórmula utilizada es la siguiente Guillermo Navarro Sánchez 33 1 1 0 0 ( , ) anchura altura i j area g i j − − = = = ∑ ∑ donde g(i,j) representa el color del pixel situado en las coordenadas i,j. 3.4 Cálculo de la orientación de un juguete Los juguetes de los cuales se necesita obtener la orientación (plastilina, recortables, muñecos) son muy diferentes entre sí y no tienen ninguna característica en común, lo único que los hace similares son su tamaño aproximado y que su imagen estará formada en su totalidad por píxeles blancos. Para el cálculo de la orientación de los fiduciales se aprovecha la distribución de las áreas blancas y negras, por ello es imposible utilizar el mismo método en los objetos sin fiducial ya que están formados en su totalidad por píxeles blancos. Por lo tanto para su cálculo, es necesario buscar algoritmos que sólo dependiesen de los descriptores de forma del objeto como pueden ser el perímetro, elongación, momentos de la imagen, etc. Para la elección de este algoritmo se han estudiado y analizado numerosas fuentes: [GW08], [MA02], [SD04], [SBBKT02], [Go06], [De01]. Todas ellas determinaban que la orientación se suele calcular haciendo uso de los momentos geométricos del objeto. Los momentos son propiedades numéricas que se pueden obtener de una determinada imagen, tienen en cuenta todos los píxeles de la imagen y no sólo los bordes. Los momentos de una imagen se clasifican en simples, centrales y centrales normalizados. En este caso se han utilizado los momentos centrales normalizados, los cuales permiten reconocer objetos dentro de una imagen independientemente de cuál sea su posición o tamaño. En concreto para el cálculo de la orientación se utilizan los momentos de segundo orden los cuales reflejan la distribución de masa de un cuerpo, respecto a un eje de giro. Los momentos de segundo orden responden a la ecuación: ( , ) ( ) ( ) ( , ) p q x y U p q x x y y g x y = − − ∑∑ donde x , y el centro de gravedad del blob y g(x,y) representa el color del pixel situado en las coordenadas i,j y donde p y q son los valores que identifican el tipo de momento, para los momentos de segundo orden se debe cumplir p+q=2. Los tres momentos centrales de segundo orden forman los componentes del tensor de inercia o matriz de rotación, siendo U(0,2), U(2,0) y U(1,1) los tres momentos de segundo orden. (0,2) (1,1) _ _ (1,1) (2,0) U U matriz de rotación U U −   =   −   Y a partir de estas componentes se puede obtener el ángulo de rotación de la figura a alrededor de su centro de masas. El ángulo de rotación φ se define como el ángulo entre el eje Reconocimiento visual de juguetes en una mesa de interacción tangible 34 de abscisas y el eje alrededor del cual el objeto puede girar con mínimo esfuerzo (eje principal). El ángulo de rotación se calcula de la siguiente forma: 1arctan 2 b a c ϕ = − siendo a, b y c los momentos de segundo orden del blob y que se calculan de la siguiente forma 1 1 2 0 0 (2,0) ( ) ( , ) anchura altura ij i j a U x x g i j − − = = = = − ∑ ∑ 1 1 0 0 (1,1) 2 ( )( ) ( , ) anchura altura ij ij i j b U x x y y g i j − − = = = = − − ∑ ∑ 1 1 2 0 0 (0,2) ( ) ( , ) anchura altura ij i j c U y y g i j − − = = = = − ∑ ∑ Siendo x , y el centro de gravedad del blob y ij x , ij y las coordenadas de los píxeles que forman el blob y g(i,j) el color del pixel situado en la coordenadas i,j. El centro de gravedad es el punto de un objeto que tiene la misma cantidad de objeto en cualquier dirección y sus coordenadas se calculan de la siguiente forma 1 1 0 0 * ( , ) anchura altura i j j g i j x area − − = = = ∑ ∑ 1 1 0 0 * ( , ) anchura altura i j i g i j y area − − = = = ∑ ∑ donde g(i,j) representa el color del pixel situado en las coordenadas i,j. Como resultado del cálculo de la orientación se obtiene el ángulo en radianes que el objeto forma con el eje de abscisas, el cual es enviado a través de TUIO al juego. Guillermo Navarro Sánchez 35 3.5 Cálculo del contorno En este apartado se explica en detalle el proceso seguido para el cálculo de los contornos de los objetos reconocidos. El cálculo del contorno de una imagen se divide en dos fases, la primera consiste en extraer los píxeles que forman parte del borde de la imagen, para luego utilizarlos en la segunda fase de cálculo de los segmentos que forman el contorno. Tras estudiar varios algoritmos para estas tareas (detallado en el Anexo C), finalmente se optó por una mezcla de dos algoritmos, el algoritmo de Moore [Oc, web] para la extracción de los píxeles y una simplificación del algoritmo de cadena [De01] para la obtención del contorno a través de los píxeles calculados en el algoritmo anterior. El algoritmo de Moore se basa en la extracción de los píxeles que forman el contorno ayudándose de la propiedad de los 8 vecinos (figura 21). Figura 21 Relación 8-vecinos. Esta propiedad consiste en lo siguiente: un pixel P x es un componente 8-vecino de un pixel dado P si comparten o bien una arista o un vértice. Por tanto un conjunto S de píxeles estará 8 conectado, si para cada par de píxeles P y P x , existe una secuencia de píxeles P…P x que cumplen que cada 2 píxeles que son adyacentes, se cumple la propiedad de que son 8- vecinos. En la figura 22 se puede ver un ejemplo de un conjunto de píxeles negros que cumplen la propiedad de 8-vecinos y en la figura 23 otro conjunto que no. Figura 22 Conjunto que cumple la 8 vecindad. Todos los píxeles comparten un vértice o una arista. Reconocimiento visual de juguetes en una mesa de interacción tangible 36 Figura 23 Conjunto que no cumple la 8 vecindad. Hay píxeles que no comparten vértices ni aristas. La idea del algoritmo consiste en ir recorriendo la imagen en orden contrario al de las agujas del reloj (se pude hacer también al revés) e ir almacenando los píxeles de color blanco del objeto que se va reconociendo. Para ello el algoritmo pasa primero la imagen del objeto reconocido a una matriz, en la cual se guarda los píxeles que forman la imagen, todos ellos blancos o negros. A continuación la matriz se recorre por columnas y de forma ascendente en busca del primer pixel blanco (en Reactivision los elementos reconocidos son blancos y el fondo negro). Una vez encontrado, se marca este pixel como pixel de comienzo y se guarda en un vector, en el que se almacenaran los píxeles que forman el contorno. Después se vuelve al pixel por el que se ha pasado justo antes de encontrar el de comienzo y se recorre los 8 vecinos de este en el orden que se haya establecido hasta encontrar un vecino que sea blanco. Una vez hallado se comprueba que no ha sido ya guardado y se almacena en el vector de píxeles de contorno. A partir del pixel detectado se vuelve a repetir los pasos anteriores. El algoritmo finaliza cuando se haya vuelto a localizar el pixel de comienzo. Un problema que presenta este algoritmo es que se puede dar el caso de volver al pixel de comienzo y que no se hayan recorrido todos los píxeles del contorno. En las figuras 24, 25 y 26 se puede ver un ejemplo de este caso. Figura 24 Se encuentra el pixel de comienzo Guillermo Navarro Sánchez 37 Figura 25 Se recorre los 8 vecinos en busca del siguiente pixel Figura 26 Se busca el siguiente pixel, pero volvemos al pixel de comienzo sin haber recorrido todos los píxeles. Para solucionar este problema, se cambió el criterio de finalización del algoritmo. Para que el algoritmo pudiese dar por concluido el proceso de búsqueda de píxeles, debía pasar por el pixel de comienzo al menos n veces. Si realizamos de esta manera la búsqueda de los píxeles en el ejemplo anterior, se comprueba como ahora sí que recorre todos los píxeles del contorno. Finalmente se estableció que se pasara por el pixel de comienzo 3 veces, se comprobó que para el tipo de objetos que tratábamos y para su tamaño, esta condición de parada era suficiente. Otro de los problemas que se detectaron fue que este algoritmo estaba pensado para imágenes sin ruido. En el caso de este proyecto al ser imágenes capturadas en tiempo real, estas suelen poseer ruido de cámara y por tanto dificultan e impiden la correcta búsqueda del pixel de comienzo. Muchas veces el algoritmo detecta un pixel de comienzo que no pertenece al objeto sino que es debido al ruido, por lo que se generan contornos erróneos. En la figura 27 se muestra un ejemplo de una detección que produciría un contorno erróneo. Reconocimiento visual de juguetes en una mesa de interacción tangible 38 Figura 27 Contorno con ruido, y que por tanto no cumple la 8-vecindad. Para solucionar este problema se recurrió al estudio de varias técnicas de eliminación de ruido: filtro de moda, filtro de media, filtro de máximos, filtro de mínimo y filtro basado en conectividad entre áreas. Tras analizarlos se determinó que los más efectivos para las imágenes que se tratan en Reactivision, eran el de media y el de conectividad, ya que estos puede adaptarse a imágenes en blanco y negro, mientras que los demás son más efectivos para imágenes en escala de grises. Primero se realiza un filtro de media a la imagen original que consiste en que para cada pixel se suma su valor y el de sus 8 vecinos, después si el resultado es superior a 0.5, se considera que el pixel tratado es blanco, en caso contrario se almacena como negro. El valor con el que se compara el resultado se puede variar en función de la concentración de ruido en la imagen. En este caso se comprobó que el valor 0.5 era el óptimo, ya que si era menor eliminaba poco ruido y si era mayor se eliminaba parte del objeto reconocido. Como la eliminación de ruido a través del filtro de media no era completa, se desarrolló otra fase de limpieza basada en un algoritmo de conectividad de píxeles. Este algoritmo consiste en etiquetar todas las áreas blancas que formen parte de la imagen y una vez obtenidas contar el número de píxeles que las forman. Como el ruido normalmente está formado por una pequeña cantidad de píxeles, se procede a convertir a negro todas las áreas cuyo número de píxeles sea inferior a 10 píxeles. Se comprobó que estas dos fases de limpieza eliminaban por completo el ruido de cámara de la imagen. Una vez obtenidos todos los píxeles que forman el contorno, es necesario ordenar empezando por el pixel de comienzo, el criterio de ordenación en este caso fue el sentido horario. De esta manera es posible asegurar que los segmentos que formen el contorno seguirán el orden correcto y no se cruzaran entre sí. En un principio este paso no se realizaba y se detectó que los contornos generados eran erróneos, en ellos aparecían líneas que se cruzaban con otras. El cruce de líneas era debido a que el algoritmo de Moore no garantiza que los píxeles sean encontrados en el orden correcto y por tanto los vértices generados tampoco lo estén. Una vez ordenados todos los píxeles del contorno se procede a aplicar una simplificación del algoritmo de cadena. El objetivo de este algoritmo consiste en simplificar el contorno que forma del objeto a través de líneas rectas. Para ello se debe reducir la matriz que contiene los píxeles obtenidos y calcular así los nodos que unirán los segmentos. Se debe escoger una densidad (número de píxeles) por la cual se divide la matriz y así queda simplificada en secciones. En el caso de este proyecto se ha escogió una densidad de 5 Guillermo Navarro Sánchez 39 píxeles. De esta manera la matriz queda dividida a la quinta parte y el contorno será mucho más sencillo. En el caso de este proyecto esta densidad es suficiente ya que no necesitamos contornos muy precisos, es decir solo necesitamos contorno aproximados de los objetos, si se necesitan contornos muy exactos tan solo hay que disminuir la densidad elegida. Una vez dividida la matriz, se consideraran nodos del contorno solo aquellos que estén más cercanos a los píxeles de contorno y en los que en su coordenada ‘x’ o ‘y’ hay un pixel de los obtenidos en el paso anterior. En la figura 28 se muestra un ejemplo de los vértices que finalmente formarán parte del contorno. Figura 28 En rojo se muestran los vértices que formarán el contorno. En negro se observa ver la silueta del objeto sin simplificar. Por último se procede a obtener los segmentos que forman el contorno: uniendo cada dos vértices mediante una línea. Sin embargo muchos de estos segmentos serán paralelos y consecutivos entre sí y podrán forman una única línea, por ello se procede al simplificado de estos en una misma línea de manera que la estructura final sea mucho más sencilla. Para simplificar los segmentos se cogen los tres primeros vértices, con el primero y el segundo se forma un vector y con el segundo y el tercero otro. De esta manera se calcula el producto escalar de estos y se obtiene el ángulo que forman. Si este ángulo es 0 indica que los segmentos son paralelos y se pueden simplificar en una sola línea, después se seguirá comprobando con los demás vértices. Si por el contrario no lo son, se almacena el vector formado por los dos primeros vértices y se pasará a comprobar los siguientes. 1 2 1 2 | || | *cos v v v v α = Reconocimiento visual de juguetes en una mesa de interacción tangible Si 0 α =  Sino En la figura 29 se puede ver un ejemplo de simplificación. Figura 29 Simplificación de los segmentos que forman el contorno. Finalmente se tienen ya almacenados los vértices y segmentos del co y sólo queda enviar esta información a los juegos que o vayan a necesitar. 3.6 Resultados obtenidos Como resultado del diseño y la implementación de los algoritmos citados se ha superado la limitación que Reactivision asociado. Se han conseguido extraer características útiles de este tipo de juguetes, que pueden ser empleadas para el diseño de juegos con nuevas funcionalidades. El cálculo del área permite obtener de superficie del tabletop, ya que hasta ahora solo a ltura y anchura. En la figura 30 obtienen unos valores de á rea u otros. Reconocimiento visual de juguetes en una mesa de interacción tangible se puede ver un ejemplo de simplificación. Simplificación de los segmentos que forman el contorno. ya almacenados los vértices y segmentos del co enviar esta información a los juegos que o vayan a necesitar. Resultados obtenidos Como resultado del diseño y la implementación de los algoritmos citados se ha Reactivision tenía frente a la detección de objetos sin fiducial asociado. Se han conseguido extraer características útiles de este tipo de juguetes, que pueden ser empleadas para el diseño de juegos con nuevas funcionalidades. El cálculo del área permite obtener de forma fiable el tamaño del objeto situado en la hasta ahora solo se tenía un cálculo aproximado a partir de su ltura y anchura. En la figura 30 se puede ver cómo según el tamaño de los objetos se rea u otros. 40 Simplificación de los segmentos que forman el contorno. ya almacenados los vértices y segmentos del co ntorno construido Como resultado del diseño y la implementación de los algoritmos citados se ha tenía frente a la detección de objetos sin fiducial asociado. Se han conseguido extraer características útiles de este tipo de juguetes, que pueden ser empleadas para el diseño de juegos con nuevas funcionalidades. objeto situado en la un cálculo aproximado a partir de su ver cómo según el tamaño de los objetos se Guillermo Navarro Sánchez 41 Figura 30 Objetos reconocidos y sus aéreas. Esta característica se ha empleado en diferentes juegos como por ejemplo en el juego de pintar. El cálculo del área de los objetos permite utilizar pinceles de diferentes grosores consiguiendo así que los trazos que se produzcan sean en función de este grosor o de la presión que el niño ejerza sobre estos, consiguiendo así aumentar las capacidades del juego. Sin esta característica se conseguirían siempre trazos del mismo grosor y se perdería la posibilidad de utilizar pinceles de diferentes tamaños. En la figura 31 se puede ver un ejemplo del juego de pintar, en el que se observan trazos de diferentes tamaños en función del pincel utilizado. Figura 31 Captura de Reactivision en la que se pueden ver los grosores de los pinceles detectados y los diferentes trazos producidos en el juego de pintar. Por otra parte la extracción de la orientación de los objetos permite saber hacia donde están apuntados los juguetes, simplemente a través de su eje principal. Notar que los ángulos siempre están comprendidos entre 0º y 180º ya que al utilizar el eje de menor inercia el cual no tiene dirección especifica. El cálculo del eje no distingue entre la parte de delante y la de detrás del objeto por lo que no se puede calcular una orientación con un rango de 360º. Esta característica permite por ejemplo calcular la dirección de un juguete sin tener que añadirle ningún tipo de fiducial. En la figura 32 se observa cómo se calcula de una forma precisa el ángulo de orientación con respecto al eje de abscisas ‘x’. Reconocimiento visual de juguetes en una mesa de interacción tangible 48 <...> <segmento x1=”” y1=”” x2=”” y2=””/> </blob> <imagen ancho=”” alto=””> <pixel cantidad=”” valor=””> <...> <pixel cantidad=”” valor=””> </imagen> donde cada etiqueta blob representa un juguete reconocido sin fiducial junto con sus características, las etiquetas segmentos representan las líneas que forman el contorno calculado del juguete y la etiqueta imagen representa la imagen que se envía de la superficie completa del tabletop. Esta última información se comprime de la misma manera que el dibujo explicado en el apartado anterior. 4.3 Resultados obtenidos Como resultado del diseño del nuevo protocolo de comunicación y de su implementación, han sido superadas las limitaciones que el protocolo TUIO presentaba en cuanto al envió de la información obtenida a través Reactivision a los juegos en Flash. En un primer lugar la utilización del lenguaje XML en el protocolo, permite el envío de datos con estructuras muy diferentes. Al ser un lenguaje de etiquetas, se pueden definir estructuras personalizadas para la información que se desee enviar. De esta manera modificando sólo la estructura del fichero, se asegura que cualquier información pueda ser enviada a los juegos. A su vez al enviarse cadenas de texto, y no paquetes con una longitud determinada, se puede enviar cualquier volumen de información, pudiendo ser cantidades de datos muy grandes. Con el protocolo TUIO nos debíamos limitar a un número muy reducido de datos y además con unas estructuras muy simples (enteros, flotantes, etc). En la figura 36 se puede ver un ejemplo de los ficheros enviados cuando se reconocen objetos sin fiducial en la superficie del tabletop. Se detectan dos objetos, por lo que se envía un fichero XML que contiene tanto las coordenadas de los objetos, su área, orientación, así como una lista de los segmentos que forman el contorno de ambos objetos. Figura 36 Objetos sin fiducial reconocidos por Reactivision y XML con la información correspondiente a dos objetos Guillermo Navarro Sánchez 49 A su vez gracias a que tanto los sockets como el lenguaje XML son multiplataforma, se asegura que sea cual sea el lenguaje en el que estén desarrollados los juegos, no habrá problema de compatibilidad con el protocolo de comunicación diseñado. Por otro lado la forma de envío de los datos y al algoritmo de compresión mejoran el envío de los dibujos en el juego de pintar. El principal problema que existía con respecto a la implementación anterior (basadas en ficheros .bmp) era la complejidad en cuanto a los pasos a implementar para la trasmisión del dibujo: • Una vez reconocido el dibujo, Reactivision generaba y guardaba el fichero .bmp en una carpeta predefinida y enviaba un mensaje TUIO al juego Flash. • Por la parte de Flash cuando se recibía dicho mensaje se accedía y leía el fichero .bmp y se mostraba en pantalla. Tras ello se procedía a borrar el fichero, ya que Reactivision no podía generar otro fichero en dicha carpeta mientras todavía permaneciese el anterior, para así evitar la sobre escritura de este mientras Flash no hubiese acabado de leerlo. Este proceso además de complejo de implementar, provocaba bloqueos de espera en Reactivision dependientes del funcionamiento de Flash. Con el nuevo protocolo el proceso es mucho más sencillo: • Reactivision envía a través de un socket los datos del dibujo y el juego Flash los recibe. Con esta situación no se producen situaciones de conflicto en los que Reactivision quede bloqueado por la ejecución de Flash. En la figura 37 se muestra un ejemplo de la cadena XML enviado al reconocer el fiducial asociado a un dibujo. En se puede observar ver la comprensión utilizada para el envío de todos los píxeles que forman la imagen. Figura 37 Dibujo reconocido en Reactivision y XML con la información correspondiente al dibujo Reconocimiento visual de juguetes en una mesa de interacción tangible 50 Capítulo 5. Interfaz de usuario. Una de los puntos más importantes en los programas informáticos es la interfaz de usuario. Una buena interfaz permite el manejo del sistema de una forma mucho más sencilla y facilita la tarea a los usuarios. Debido a las nuevas funcionalidades realizadas en este proyecto se ha modificado la interfaz de usuario de manera que integre las nuevas funcionalidades y parámetros utilizados. A su vez se han modificado y mejorado los ficheros de configuración de Reactivision incluyendo la posibilidad de añadir los nuevos parámetros generados así como otros que no estaban previamente incluidos. En este capítulo se detallan las modificaciones realizadas en el interfaz de usuario y las mejoras incluidas en los ficheros de configuración. 5.1 Interfaz de usuario La configuración y visualización de las opciones se desarrolló de forma similar al resto de configuraciones de valores en Reactivision. Todas ellas se basan en la visualización por pantalla de barras en las que se puede observar el valor de la variable a tratar y en algunas ocasiones estos valores se acompañan de gráficos para identificar de manera más clara as modificaciones realizadas. El acceso al menú de interfaz de usuario se realiza mediante teclado y en la ventana de inicio de Reactivision se pueden observar las teclas a pulsar para acceder al menú de cada uno de los elementos configurables. Una vez dentro de cada menú, los valores se modificarán utilizando las flechas ‘derecha’ e ‘izquierda’ y la navegación por el menú será a través de las flechas ‘arriba’ y ‘abajo’. En la figura 38 se puede ver la ventana de inicio y las diferentes opciones de configuración. Figura 38 Ventana de inicio de Reactivision La función para ello modificada ha sido drawGUI, encargada de mostrar y gestionar los cambios en los diferentes parámetros configurables. Para la configuración de los nuevos Guillermo Navarro Sánchez 51 fiduciales, se ha añadido la posibilidad de controlar el número de píxeles blancos que estos deben tener por lo tanto como el tamaño de los agujeros también viene en relación con el tamaño del área blanca del fiducial, esta opción permite controlar el tamaño de los fiduciales. Esta nueva opción complementa a la posibilidad de cambiar el tamaño de los finger detectados (opción por defecto en Reactivision), ya que los nuevos fiduciales comparten las opciones de tamaño de éstos. Además la posibilidad de regular el área blanca de los fiduciales permite asegurar que estos no son confundidos con ruido de cámara, tal y como se ha explicado en el capítulo 2. El menú para cambiar estos valores se activa pulsando la tecla ‘f’. En la figura 39 se puede ver las distintas opciones de configuración de los nuevos fiduciales. Figura 39 Menú de configuración del número de píxeles blancos de los nuevos fiduciales La interfaz también se ha modificado para permitir configurar el tamaño de los folios donde los niños pueden dibujar en el juego de pintar, así como el fiducial que éste lleva asociado. Hasta ahora se podía modificar los valores de altura y anchura del papel así como el tamaño del fiducial, sin embargo estos valores eran difíciles de comprender por parte del usuario, ya que estaban expresados en píxeles lo que hacía difícil hacerse a la idea del tamaño real del papel y su fiducial. Para eliminar esta limitación se ha asociado al menú de configuración unos gráficos que representan el tamaño del papel una vez reconocido por Reactivision, de manera que el usuario antes de empezar a jugar puede colocar un papel en el tabletop y configurar su tamaño visualizando en todo momento el área capturada. En la figura 40 se puede ver el menú de configuración del papel. Este menú se activa con la pulsación de la letra ‘b’. Reconocimiento visual de juguetes en una mesa de interacción tangible 52 Figura 40 Menú de configuración del papel, para el juego de pintar. 5.2 Ficheros de configuración Uno de los problemas que presenta Reactivision es la inicialización de los parámetros que se van a utilizar en los juegos: tamaños del fiducial, de los fingers, de los objetos sin fiducial, de los folios para dibujar, etc. Cada vez que se quiere jugar, lo primero que hay que hacer es configurar todos los valores de estos parámetros, para el reconocimiento de los juguetes a utilizar. Este requerimiento es repetitivo y poco práctico, por lo que en este proyecto se han modificado los ficheros de configuración que Reactivision usaba por defecto, de manera que todos los parámetros se pudiesen incluir en ellos y no hubiese que configurarlos al inicio de cada juego. Así para cada vez que se quiera jugar, solamente se debe cargar el fichero correspondiente a ese juego y todos los valores de los parámetros serán inicializados automáticamente. A continuación se detallan las posibilidades de configuración incluidas en los ficheros y su modo de funcionamiento. Objetos sin fiducial La siguiente instrucción se añade para configurar los parámetros de tamaño de los juguetes que no llevan asociado un fiducial es: <handler min="20" max="200" /> La etiqueta handler, indica que se modifica el tamaño de los objetos sin fiducial que reconoce el juego. Los parámetros min y max son los tamaños mínimo y máximo que los Guillermo Navarro Sánchez 53 juguetes pueden tener en el juego. Cualquier juguete sin fiducial con un tamaño fuera de este rango no será reconocido. Nuevos fiduciales La siguiente instrucción configura los parámetros de los nuevos fiduciales: <finger size="26" sensitivity="74" num_blancos="520" /> num_blancos es el número de píxeles blancos que debe tener un fiducial de la nueva colección como mínimo para que sea considerado fiducial de este tipo. Si se omite este parámetro, el valor por defecto será 500. Además se añadió una posibilidad de indicar si iban a ser utilizados fiduciales de este tipo o juguetes sin fiducial <mode object="finger2" /> <mode object="blob" /> La etiqueta mode indica el modo en el que se trabaja y el parámetro object indica si se va a trabajar con fiduciales de la nueva colección o bien objetos sin fiducial. Si este parámetro tiene el valor finger2, indica que se van a utilizar fiduciales de la nueva colección, mientras que si tiene el valor blob, serán los objetos sin fiducial los reconocidos. Esta opción es excluyente, lo que indica que no pueden utilizarse a la vez ambos tipos de objeto. Si se utilizan fiduciales de la nueva colección, los objetos sin fiducial no serán reconocidos y viceversa. Si se omite esta línea en el fichero de configuración indica que en el juego no se van a utilizar fiduciales de la nueva colección ni objetos sin fiducial, de manera que ninguno de ellos será reconocido aunque sean colocados en el tabletop. Papel de dibujo Para configurar los parámetros de tamaño del papel que contendrá los dibujos, así como el del fiducial asociado, la instrucción que hay que añadir es: <paper height="210" width="300" fid_size="20" /> La etiqueta paper, indica que vamos a modificar el tamaño de las hojas de papel en el juego. Los parámetros height y width indican la altura y anchura de la hoja de papel a utilizar y fid_size indica el tamaño del fiducial identificador de la hoja de papel. Reconocimiento visual de juguetes en una mesa de interacción tangible 54 Si se omite esta línea en el fichero de configuración indica que no se van a utilizar papeles para dibujo en el juego, de manera que no será reconocido ningún dibujo colocado en el tabletop. Protocolo de comunicación En el fichero de configuración se ha añadido el parámetro segundos que indica cada cuanto tiempo se envía la cadena XML con la información de los objetos sin fiducial al juego en flash. <tiempo segundos="10" /> Si la línea se omite, el programa no envía el fichero XML con la información correspondiente a los juguetes reconocidos. Así mismo se incluye la posibilidad de poder indicar el número identificador del fiducial asociado a los dibujos en el juego de pintar. <dibujo id="11" /> id indica el identificador del fiducial que tendrá la hoja del dibujo asociado. Si la línea se omite, el programa asigna por defecto el valor -1 y no será reconocido ningún fiducial como perteneciente al dibujo. En la figura 41 se muestra un ejemplo de fichero de configuración. Este fichero indica que se reconoce dibujos con un tamaño de 384*165 píxeles y con un fiducial asociado de 50 píxeles. A su vez se reconocen los juguetes sin fiducial de entre 25*25píxeles y 150*150píxeles. Se reconocerá también fingers con un tamaño de 32*32píxeles y fiduciales cuya topología este almacenada en el fichero árboles miniset.trees. Por último se indica que cada 5 segundo se envía la información de los juguetes sin fiducial a los juegos, mediante el nuevo protocolo de comunicación. También se envía a través de él un fichero con la información del dibujo cada vez que se reconozca el fiducial con identificador 10. Figura 41 Ejemplo de fichero de configuración de Reactivision. Por último se modificó la gestión de los ficheros de configuración por parte de Reactivision para que permita leer también los nuevos parámetros añadidos y a su vez guardase los cambios realizados a través del interfaz de usuario, de manera que no fuera necesario memorizar estos valores para después ser añadidos a mano en los ficheros, Guillermo Navarro Sánchez 55 haciendo así mucho más cómodo el manejos al usuario. Para ello se utilizó la clase TiXmlDocument, la cual permite un rápido manejo de las etiquetas XML. Las funciones modificadas fueron readSettings, función que se encarga de leer y cargar los valores de los parámetros almacenados en el fichero de configuración y writeSettings encargada de actualizar y guardar los cambios realizados en los parámetros durante la ejecución. Reconocimiento visual de juguetes en una mesa de interacción tangible 56 Capítulo 6. Resultados. Tras la finalización de cada uno de los objetivos desarrollados durante este proyecto, se han creado juegos para comprobar que cumplían la función de mejora del framework. En este capítulo se presentan los juegos realizados a raíz de las mejoras explicadas en los capítulos anteriores. En el anexo D se hace un estudio y comparación de otros tabletops y frameworks en el mercado. 6.1 Secuenciador. El secuenciador es un juego de música en el que los niños pueden crear ritmos de batería usando las clásicas fichas circulares del juego de las damas. La partitura utilizada para crear ritmos musicales, se puede entender como una distribución de notas musicales (las fichas), sobre una superficie bidimensional (la mesa), en el que el eje horizontal representa el tiempo, y el horizontal los diferentes instrumentos de la batería, representados con diferentes colores (ver fig. 42). La partitura se reproduce de izquierda a derecha. Figura 42 Capturas del juego secuenciador. Para que las fichas fueran identificadas por Reactivision, se ha usado la nueva colección de fiduciales. Como en el juego de las damas, tenemos dos tipos de fichas, las blancas, y las negras. A estas últimas se les añadió un fiducial de la nueva colección con un único punto negro (ver fig. 43). Guillermo Navarro Sánchez 57 Figura 43 Fichas usadas en el juego de música ‘Sencuenciador’ y los fiduciales asociados a estas La partitura mostrada en la mesa consiste en una rejilla de 8 instrumentos por 16 tiempos, por lo que sería posible incluir hasta 128 fichas para llenar toda la partitura de sonidos. Esto sería imposible usando fiduciales estándar de Reactivision, ya que dado el tamaño mínimo que deberían tener las fichas, no cabrían todas en la mesa. Gracias a los nuevos fiduciales diseñados, estos pudieron ser añadidos sin problemas a fichas normales de juego de damas, cuyas dimensiones permiten llenar toda la partitura. Los nuevos fiduciales permiten además que Reactivision distinga entre las fichas blancas y negras. En el juego del Secuenciador, dicha distinción se utiliza para variar el tono del instrumento sobre el que está colocada la ficha. En el caso de los instrumentos de percusión (platos, bombo…) las fichas negras tienen un sonido más agudo y corto que las blancas. En el caso de los instrumentos de cuerda (bajo), se ha utilizado un diseño de fiducial orientable, de forma que girando la ficha sobre la mesa, se varía el tono a lo largo de la escala musical, pudiendo componer una melodía de hasta 16 notas. Por otra parte el juego permite a grupos de niños crear y compartir sus creaciones, gracias al gran número de fichas de las que disponen, evitando situaciones de dominio de los juguetes por solo un niño. Se trata de un juego muy activo y participativo cuando juegan muchos niños (ver fig. 44) Figura 44 Niños jugando al juego del Secuenciador. Reconocimiento visual de juguetes en una mesa de interacción tangible 64 7.2 Valoración personal Desde un punto de vista personal el desarrollo de este PFC ha supuesto: 1. La oportunidad de aplicar los conocimientos adquiridos a lo largo de la carrera y aprender aquellos necesarios para la correcta realización del proyecto. 2. El llevar a cabo un proceso completo de diseño, desde las primeras fases de análisis hasta la posterior implementación de las funcionalidades. 3. El trabajar en un proyecto real, cooperando con un grupo de investigación multidisciplinar en un tema de investigación puntero. 4. La comprobación el resultado obtenido con usuarios reales, lo que ha provocado un feedback del trabajo conseguido. Además el trabajar con niños, un tipo de usuario muy exigente, ha facilitado la mejora de las funcionalidades a través de las conclusiones obtenidas de sus reacciones. 7.3 Trabajo futuro La realización de este proyecto ha abierto nuevas posibilidades de interacción en NIKVision. En un futuro se podrán crear nuevos videojuegos a partir de las funcionalidades desarrolladas, así como crear otros nuevos que abran a su vez nuevas modalidades de juego. Las nuevas funcionalidades implementadas durante este proyecto dan pie a nuevas líneas de trabajo ya que actualmente no existen diseños de fiduciales que puedan ser adaptados a la base de otros tipos de juguetes en NIKvision (ver fig. 52). En este caso se debería crear fiduciales con forma de arandela y correspondientes algoritmos para su reconocimiento. Figura 52 Juguetes que necesitan de nuevos fiduciales, ya que sus bases poseen agujeros que s taparían con los fiduciales actuales Guillermo Navarro Sánchez 65 Así mismo sería interesante que las funcionalidades realizadas pudieran ser replicadas en otros populares frameworks para tabletops como CCV (NUI Group, web), expandiendo así el número de diseñadores para tabletops que podrían hacer uso de lo desarrollado en este proyecto. Por otra parte las nuevas funcionalidades debería dar paso a crear algún tipo de interfaz de usuario mediante el que se puedan generar de forma automática los ficheros de configuración, únicamente a través de la selección sencilla del tipo de juguetes a emplear. Reconocimiento visual de juguetes en una mesa de interacción tangible 66 Anexo A. Reactivision y TUIO. A.1 Estructura de Reactivision A continuación se analiza la estructura de Reactivision, explicando en qué consiste su funcionamiento y las posibilidades de configuración. A.1.1 ¿Qué es Reactivision? Reactivision es un framework de visión por computador de código abierto y multiplataforma, pensado para la detección rápida y estable de fiduciales incorporados a objetos físicos así como de acciones táctiles [KB07]. Fue diseñado principalmente como un conjunto de herramientas para el rápido desarrollo de tabletops y superficies interactivas. El sistema fue desarrollado por Martin Kaltenbrunner y Ross Bencina en el Music Technology Group de la Universitat Pompeu Fabra en Barcelona, España, como parte del proyecto Reactable, tabletop que funciona como un instrumento musical, que se explica más en detalle en el anexo D. A.1.2 Funcionamiento de Reactivision Reactivision obtiene la información de una mesa transparente a través de una cámara y la procesa para detectar los objetos marcados con fiduciales o los dedos de las manos, la información extraída se envía después a otras aplicaciones a través del protocolo TUIO, que se explica de apartados siguientes. En la figura 53 se observa un diagrama del funcionamiento de Reactivision: la cámara capta la imagen con los fiduciales situados sobre la mesa, envía los datos a Reactivision que tras procesarlos envía la información extraída mediante TUIO a una aplicación TUI (Tangible User Interface) que la usará, por ejemplo los juegos. Por último se muestran los resultados mediante un proyector en la superficie de la mesa. Figura 53 Diagrama general del funcionamiento de Reactivision en un tabletop. Guillermo Navarro Sánchez 67 Tras capturar la imagen Reactivision la pasa a través de una serie de procesadores que la transforman, para después obtener información de esta. Las fases seis fases que conforman el framework en orden de procesamiento son: captura, ecualización, umbralización, detección de fiduciales, calibración y envió de mensajes. Figura 54 Paso de la información en Reactivision En la figura 54 se muestra un diagrama del procesamiento de la imagen capturada. Cada una de las fases se encarga de una función en concreto, las cuales se detallan a continuación: Captura de la imagen: El primer paso consiste en la captura de una imagen y su almacenamiento en un buffer de imágenes. Ecualización: Es la fase que se encarga de tratar la imagen inicial que le envía la cámara eliminando los elementos erróneos de ésta. Umbralización: Se encarga de pasar la imagen a escala de grises para convertirla en una imagen binaria, es decir, solo en dos colores, negro y blanco. Para ello realiza una umbralización de la imagen separando el fondo de los objetos, siendo el fondo negro y los objetos de color blanco. Detección de fiduciales: En esta fase es donde se analiza la imagen para detectar los fiduciales y objetos que se coloquen en la superficie del tabletop. Reconocimiento visual de juguetes en una mesa de interacción tangible 68 Calibración: Se encarga de corregir la aberración de la cámara que provoca que la geometría de los objetos captados no sea la correcta. Esto se hace a través de una transformación de coordenadas, de manera que exista una correspondencia entre las coordenadas reales y las captadas por la cámara. Envío de mensajes: Por ultimo toda la información obtenida después del tratamiento se envía a las aplicaciones a través del protocolo TUIO. En cada ejecución y cuando los valores del fichero de configuración han sido cargados, es cuando se comienza a trabajar en la detección de objetos. En primer lugar se comprueba si la cámara está conectada, de lo contrario se informará de ello mediante un mensaje de error. A continuación se muestra por pantalla la resolución de la cámara y el tipo de esta, así como los diferentes comandos de configuración del framework. En la figura 55 se muestra la ventana de inicio de Reactivision, en la que se observa la fecha de ejecución, el tipo de cámara y la resolución de esta, en este caso 640x480 píxeles. A continuación se pueden ver las diferentes opciones de configuración tanto de los procesadores, como de las variables que el framework utiliza. Figura 55 Ventana e inicio de Reactivision Las fases de ecualización, umbralización, detección de fiduciales y calibración se pueden configurar. Esta configuración, como se ha explicado en el capítulo 5 se guarda después de cada ejecución, de manera que puede volver a recuperarse los parámetros de cada procesador en usos posteriores. La configuración se guarda en un fichero XML, que almacena los valores de las variables de cada procesador, así como el valor de las variables que se vayan a necesitar. Reactivision es el encargado de cargar este fichero de configuración al iniciar su ejecución. Guillermo Navarro Sánchez 69 A.1.3 Fases de Reactivision A continuación se van a explicar más en detalle cada una de las fases que conforman el framework Reactivision. A.1.3.1 Captura de imágenes La captura de imágenes a través de la cámara se realiza de forma paralela al programa principal, ya que se necesita estar tomando imágenes en todo momento para actualizar los valores de posición, orientación, etc de los objetos así como reconocer los nuevos objetos colocados entre captura y captura. Si la captura de imágenes no se hiciese de forma paralela al procesamiento, el programa principal no podría tatar la imagen en ningún momento o por el contrario al no tomar imágenes continuamente se estarían perdiendo parte de las interacciones con la mesa. Este proceso captura frames y los va guardando en un buffer, pudiendo almacenar 3 imágenes de forma simultánea. Si el buffer se encuentra lleno, se realiza una comprobación del estado de la cámara y si ésta sigue en funcionamiento se espera un tiempo de 5 segundos y después se vuelve a intentar guardar una nueva imagen, de esta manera se evita la saturación del buffer. En caso de que la cámara no responda, se aborta la captura de imágenes. A.1.3.2 Ecualización Este es la primera fase en la que se modifica la imagen. Sirve para eliminar objetos erróneos o no necesarios en la imagen. Al capturar por primera vez una imagen, ésta contendrá ruido y errores por la mala iluminación o calibración de la cámara. Para evitar en gran medida la captura de ruido, este proceso indica al framework que la primera imagen que tome deberá ser tratada como fondo, de esta manera toda la información que sea errónea será ignorada. Este proceso se puede activar y desactivar pulsando la tecla 'e'. El fondo se puede poner a negro pulsado la barra espaciadora, de esta manera se evitaran falsos positivos en el reconocimiento ya que esta será la imagen tomada como fondo. En la figura 56 se puede ver cómo se elimina el ruido y errores en la imagen pulsando la tecla espaciadora y así indicando al ecualizador que el fondo es todo negro. Figura 56 Imagen antes y después de ecualizar. Reconocimiento visual de juguetes en una mesa de interacción tangible 70 A.1.3.3 Umbralización Este fase consiste en umbralizar ecualizada para transformarla en una imagen binaria, es decir en blanco y negro. El procedimiento consiste en ir recorriendo la imagen formando regiones de 6x6 píxeles junto a sus 8 vecinos. En cada región se comprueba el mínimo y el máximo valor de los píxeles y después se compara la diferencia de dichos valores con el valor del gradiente. Si esta diferencia es mayor que el gradiente, se considera que la región pertenece al fondo y por tanto se le asigna el color negro. Si por el contrario es menor que el gradiente, se comprueba si esta diferencia es menor que el valor 127, valor medio del total de escala de grises, si es menor pasa a ser blanco y sino a negro. El valor del gradiente puede modificarse pulsando la tecla 'g'. En la figura 57 se muestra una imagen ecualizada y el resultado tras ser umbralizada. Figura 57 Imagen antes y después de umbralizar. A.1.3.4 Detección de fiduciales Tras la umbralización de la imagen, se pasa a buscar los fiduciales y los objetos sin marcar. Para la identificación, lo primero que se realiza es una segmentación de la imagen, es decir una división de la imagen en regiones. Se comienza recorriendo la primera línea de la imagen pixel a pixel. En el momento que se detecta un pixel, se crea una nueva región si éste es de distinto color al anterior pixel o actualizamos la región del pixel anterior si es del mismo color. Tras analizar la primera línea, se pasa a realizar el mismo proceso con las siguientes líneas, con la salvedad de que ahora también se comprueba el pixel superior al que se está analizando, además del anterior. Cuando un pixel comparte región tanto con su pixel superior como el de su izquierda, se procede a una fusión de sus regiones, dando lugar a una nueva [BKM05]. Una vez segmentada la imagen, se procede a la búsqueda de los fiduciales que coincida con los almacenados en el fichero de árboles que contiene el framework al ejecutarse. Una vez reconocidos todos los fiduciales colocados sobre la superficie de la mesa, se comprueba que estos fiduciales sean válidos, nuevos o si ya habían sido reconocidos. Para ello lo que el algoritmo hace es comprobar los fiduciales reconocidos con los reconocidos en el frame anterior. Uno a uno comprueba los fiduciales con los ya reconocidos, si se produce una coincidencia se compara la distancia entre los dos y si es menor que el tamaño mínimo de un fiducial, se entiende que se trata del mismo objeto y que simplemente ha sido movido de una Guillermo Navarro Sánchez 71 frame a otro, por lo que se procede a actualizar sus valores de posición y orientación. Si por el contrario no coincide con ninguno de los fiduciales ya detectados, se añade este a la lista de nuevos fiduciales. Una vez detectados los fiduciales convencionales de Reactivision, se pasa a buscar los desarrollados en este proyecto. Para ello se busca en las imágenes segmentadas, regiones del tamaño establecido por parte del usuario, para después realizar un etiquetado de las zonas según su color como se ha explicado en el capítulo 2. Tas el etiquetado se realiza una detección de agujeros en estas zonas. Y por último para cada nuevo fiducial, se comprueban si sus agujeros cumplen las restricciones de tamaño, así como si cumple las restricciones de área blanca que debe tener. Para evitar falsos positivos y no confundir los nuevos fiduciales con los ya detectados (tanto de la nueva colección como de los convencionales), se procede a realizar una comprobación similar a la explicada en el párrafo anterior. Por último, se buscan los objetos sin fiducial y posibles fingers. Para ello se examinan las regiones de color blanco y de un determinado. Los tamaños que pueden tener tanto los objetos como los fingers se puede modificar a través del interfaz de usuario como se ha indicado en el capítulo 5. Una vez detectada las regiones del tamaño establecido, se comprueba que no se trata de objetos que ya se habían detectado anteriormente, para ello se compara la distancia entre cada uno de los nuevos objetos y los ya detectados. Por último y una vez detectados todos los objetos sin fiducial, se procede a extraer las características de estos (área, orientación y contorno) tal y como se ha explicado en el capítulo 3. Tras haber reconocido todos los objetos situados en la superficie de la mesa, se procede a identificarlos gráficamente en la pantalla de Reactivision. Los fiduciales serán identificados con un número, según su posición en el fichero de árboles antes mencionado. Los dedos de las manos se mostrarán con la letra 'F' y los objetos sin fiducial con la letra 'B'. En la figura 58 se muestra un ejemplo de los objetos que se han reconocido identificados con las correspondientes letras y números. Figura 58 Objetos reconocidos en Reactivision Reconocimiento visual de juguetes en una mesa de interacción tangible 72 A.1.3.5 Calibración Por último se procede a la calibración de la imagen. Esta fase consiste en una conversión entre las coordenadas reales y las obtenidas por la cámara estableciendo así una relación entre ellas. Esto es necesario ya que las cámaras producen aberraciones ópticas, distorsionando la imagen respecto a la realidad, por lo que a la hora de representar elementos en unas coordenadas determinadas, este objeto puede no quedar situado en la posición esperada. El calibrador puede activarse pulsando la tecla 'c'. Al hacerlo se muestra una rejilla formada por líneas y puntos que se pueden mover por la pantalla. El desplazamiento y modificación de los puntos provoca que las zonas de la imagen dada por la cámara que coincidan con esos puntos, se deformen hasta los nuevos puntos establecidos. En las figuras 59 y 60 se observa una imagen sin calibrar y el efecto que se produce al mover los puntos de la rejilla para ajustarlos a la imagen real. Figura 59 Imagen sin calibrar Las líneas azules y verdes corresponden al calibrador. Las líneas en negro pertenecen a la imagen real y de cómo tendrían que ser las líneas del calibrador. Se puede ver que no coinciden unas con otras. Guillermo Navarro Sánchez 73 Figura 60 Imagen calibrada Después de calibrar, se puede comprobar que las líneas negras corresponden con las del calibrador. A.1.3.6 Envío de mensajes Por último toda la información obtenida después del tratamiento se envía a las aplicaciones a través del protocolo XML explicado en el capítulo 4 y el protocolo TUIO detallado en los apartados siguientes. A.2 Estructura TUIO A continuación se analiza la estructura del protocolo de comunicación TUIO, explicando en qué consiste su funcionamiento y la información que puede enviar. A.2.1 ¿Qué es TUIO? Se trata de un protocolo diseñado específicamente para cumplir las necesidades de comunicación que presentan los tabletops. Este protocolo define las propiedades comunes que presentan los objetos identificados con fiduciales, así como los movimientos del dedo realizados por el usuario. Su función principal es el envío de la información extraída por las aplicaciones de reconocimiento a las aplicaciones que vayan a usar esta información, en el caso de este proyecto los juegos. TUIO se basa en Open Sound Control- OSC, un estándar emergente para entornos interactivos, diseñado en un principio para tabletops musicales. Inicialmente TUIO fue diseñado junto con Reactivision para el proyecto Reactable [Reactable, web], tabletop diseñado en la Universidad Pompeu Fabra, que se explica en el anexo D. Hoy Reconocimiento visual de juguetes en una mesa de interacción tangible 80 SetupCamera(): Inicializa la cámara para que proceda a la captura de imágenes. TeardownCamera(): Deja de usar la cámara. InitFrameProcessors(): Inicializa todos los procesadores de frames que tiene añadidos. Si alguno no se puede inicializar, lo elimina. AllocateBuffers(): Establece el tamaño de los buffers de origen, destino y display y los reserva en memoria. FreeBuffers(): Elimina de memoria el espacio reservado para los buffers. EndLoop(): Finaliza la ejecución de los procesadores de información, mostrando por pantalla un mensaje de error si han finalizado por esa razón. Process_events(): Gestiona el manejo de eventos, que en este caso son las acciones que activan la pulsación de las teclas de opciones. FidtrackFinder Clase que se encarga de buscar fiduciales y objetos sin identificador en los frames. Atributos: detect_finger: Booleano que active o desactiva la detección de dedos. average_leaf_size: Indica el tamaño de los nodos hoja de los fiduciales. average_fiducial_size: Indica el tamaño que deben tener los fiduciales. average_finger_size: Indica el tamaño que deben tener los dedos de las manos para ser reconocidos. finger_sensitivity: Indica la tolerancia de error del tamaño de los dedos para ser reconocidos. num_blancos: Número de píxeles blancos que debe tener un fiducial de la nueva colección. min_handler_size: Tamaño mínimo que debe tener un objeto sin identificador con un fiducial. max_handler_size: Tamaño máximo que debe tener un objeto sin identificador con un fiducial. paper_height: Indica la altura del folio que contenga el dibujo a reconocer. paper_width: Indica la anchura del folio que contenga el dibujo a reconocer. fid_size: Tamaño que debe tener el fiducial que identifica al dibujo a reconocer. Modo: Indica el modo de reconocimiento: blob si debe reconocer objetos sin fiducial y finger2 si tiene que reconocer fiduciales de la nueva colección. tiempo_xml: Indica el número de segundos que deben pasar entre envíos del fichero XML que contiene los datos extraídos. fid_dibujo: Identificador del fiducial que acompaña al dibujo. Socket: Socket que conecta a Reactivision con el juego. anterior, ahora: Variable que nos indican el tiempo que ha pasado desde el último envió del fichero XML. setFingerSize, setFingerSensitivity, setNumBlancos, setHandlerSize, setMinimun, setPaperBlockSize, setHeight, setWidth, setFiducialSize: Booleanos que indican que valor a de aparecer en el display para su configuración. Detectado: Booleano que indica que fiducial que acompaña al el dibujo ha sido detectado. Guillermo Navarro Sánchez 81 Tiempo: Tiempo que debe pasar el dibujo sin moverse para ser capturado. Guardado: Indica que el dibujo ha sido reconocido y guardado. Métodos: FidtrackFinder(MessageServer *server, const char* tree_cfg, const char* grid_cfg, int finger_size, int finger_sens): Constructor de la clase que da valor al servidor que envía los mensajes con lo detectado (server), al fichero de configuración de los árboles de los fiduciales (tree_cfg), a la superficie calibrada (grid_cfg), al tamaño de los dedos que se van a detectar (finger_size) y a la variación de tamaño que se establece para detectar un dedo (finger_sens). Además realiza la llamada a la conexión socket, en el caso de que esta opción este activada. Init(int w ,int h, int sb, int db): Inicializa el procesador de detección. GetFingerSize(): Devuelve el valor del tamaño de los dedos que se quieren detectar. GetFingerSensitivity(): Devuelve la variación de tamaño que puede tener un dedo para que, aunque no sea del tamaño exacto, se pueda detectar. Process(unsigned char *src, unsigned char *dest, SDL_Surface *display): Realiza la segmentación y procesado de la imagen umbralizada para detectar fiduciales y dedos y objetos sin fiducal y muestra los datos por el display. En este método se han realizado modificaciones para realizar la detección del fiducial de la captura de dibujo, contabilizar el tiempo que está quieto y enviar la información para que la use la aplicación juego. También se ha realizado el cálculo de la orientación de los objetos sin fiducia, así como el cálculo del área y contorno de estos. Una vez calculado todo se procede al envío de la información a través del protocolo diseñado usando sockets y el fichero XML, todo ello explicado en el capítulo 4. DrawGUI(SDL_Surface *display): Dibuja en el display la información sobre el tamaño de los dedos que se van a detectar para que se pueda modificar, mostrando el tamaño que deben tener para ser reconocidos. Aquí se han realizado modificaciones para poder mostrar las opciones de configuración del tamaño de la zona de captura del dibujo (con sus máximos y mínimos) así como otras variable para el reconocimiento de la nueva colección de fiduciales como el número de píxeles blancos que deben tener. Las opciones son mostradas como una barra horizontal en la que se aumenta o disminuye su valor y el tamaño del dibujo a través de una grafica. ToggleFlag(int flag): Realiza la gestión de teclas para la configuración del detector. En la gestión se han incluido también las teclas para lanzar la configuración (m y b). Cuando se están modificando los valores de configuración no se puede llamar a ninguna de las otras opciones de modificación de Reactivision hasta que no se termine de darles valores. limpia_imagen(int **imagen_sucia, int **imagen_limpia, int ancho, int alto): Realiza un filtro de media a imagen_sucia y el resultado es almacenado en imagen_limpia. Sirve para eliminar el ruido de la imagen tomada y poder enviar un resultado optimo en el fichero XML. siguientMovimiento(int actual_i, int actual_j, int anterior_i, int anterior_j): Dadas las coordenadas del pixel actual y el anterior, devuelve el siguiente movimiento realizar en la búsqueda de los píxeles del contorno. Reconocimiento visual de juguetes en una mesa de interacción tangible 82 siguienteVertice(int **vertices, int i, int j, int numVertices): Devuelve el siguiente vertice al de coordenadas (i,j) en sentido horario. ordenar_píxeles(int **vertices, int numVertices, int **verticesOrdenados): Ordena los vértices en sentido horario y almacena el resultado en verticesOrdenados busca_nodos(int **verticesOrdenados, int numVertices, int ancho, int alto, int **verticesContorno): Busca los nodos que formaran los segmentos del contorno, a partir de los píxeles del borde del objeto. sonParalelos(int x1, int y1, int x2, int y2, int x3, int y3): Devuelve cierto si los segmento (x1,y1 – x2,y2) y (x2,y2 – x3,y3) son paralelos. En caso contrario devuelve falso. etiquetar_matriz(int **matriz_limpia, int **matriz_etiquetada, int ancho, int alto): Realiza el etiquetado de las áreas negras de matriz_limpia y el resultado lo devuleve en matriz_etiquetada FingerObject: Clase que representa un objeto sin fiducial o un dedo de la mano con sus propiedades. Con la nueva implementación realizad además también representa a los blobs mano y objetos planos. Atributos: Alive: Indica si el objeto reconocido se encuentra activo en el último frame analizado. Unsent: Indica si el objeto reconocido está siendo detectado, pero todavía no se ha enviado información sobre él. Session_id: Identificador de sesión del objeto reconocido. State: Estado del objeto reconocido: añadido, borrado, expirado o vivo. Smallest_area: mínima área que el objeto reconocido tiene que tener para ser detectado. Xpos, ypos: posición en pantalla del objeto reconocido. Además se ha incluido un campo que contiene la información sobre la orientación. Métodos: FingerObject(int width, int height): Constructor de la clase usando como parámetros su altura y anchura (width, height). Update(float xpos, float ypos, float area): Actualiza la información del objeto reconocido en pantalla: su nueva posición y su nueva área. update(float xpos, float ypos, float area, double orientacion): Actualiza la información del objeto reconocido en pantalla: su nueva posición,su nueva área y su orientación. RedundantSetMessage(TuioServer *server): Crea un mensaje para enviarlo mediante protocolo TUIO cuando no se ha modificado ninguno de sus parámetros. GetStatistics(): Devuelve una cadena con toda la información del objeto reconocido. CheckStatus(int s_id): Devuelve el estado del objeto reconocido indicado (s_id). Este estado puede ser: añadido, borrado, expirado o vivo. Update(float xpos, float ypos, float area, float orientacion): Actualiza la información del objeto reconocido, en la que también se incluye la orientación. Guillermo Navarro Sánchez 83 AddSetMessage(TuioServer *tserver): Crea un mensaje para enviarlo mediante el protocolo TUIO a otra aplicación cada vez que el objeto reconocido se actualiza. En el mensaje también se añade la información sobre la orientación del objeto reconocido. Distance(float x, float y): Calcula la distancia entre un punto de la pantalla (x, y) y el centro del objeto reconocido. Reset(): Inicializa la información del objeto reconocido. GetX(): Devuelve la posición horizontal del centro del objeto reconocido. GetY(): Devuelve la posición vertical del centro del objeto reconocido. GetOrientacion(): Devuelve la posición orientación de objeto reconocido, sólo para objetos sin fiducial. XmlSocket: Clase que representa al socket que conecta a Reactivision con los juegos en Flash. Sirve para el envío del fichero XML que contiene los datos extraidos de los objetos reconocidos. Atributos sendBuff: Buffer que almacena la información a enviar. fd: Identificador del socket. Métodos: XmlSocket(): Constructor de la clase. Run(): Envía la política de conexión al juego y le indica el puerto del socket al que se tiene que conectar (3335). Conexion(): Crea el socket y se queda esperando a que el juego se conecte. Envia(char sendBuff[]): Envía el fichero XML generado al juego. B.3.3 Glosario de términos El diccionario de datos contiene una lista de conceptos básicos necesarios para la correcta interpretación de algunos de los aspectos del proyecto. Blob : Elemento de una imagen que viene determinado por ser un conjunto de píxeles de un color en una región discreta, rodeada por píxeles de otros colores. En el caso de este proyecto los blobs son binarios, o blancos, o negros. Fiducial: Imagen usada para identificar un objeto mediante un sistema de detección visual. Esta imagen puede dar información, sobre el tipo de objeto que es, la orientación y la posición del objeto. La imagen consiste en un conjunto de elementos blancos y negros. Frame: Imagen part icular que se encuentra dentro de una sucesión de imágenes que componen una animación o video. La sucesión continua de estas imágenes producen sensación de movimiento, provocado por las pequeñas diferencias que hay entre cada una de estas. Reconocimiento visual de juguetes en una mesa de interacción tangible 84 Framework: Est ructura software de soporte en la que otro proyecto de software puede ser organizado y desarrollado. Esta estructura permite facilitar el desarrollo del software, evitando los detalles de bajo nivel para poder destinar tiempo y esfuerzo a identificar los r equerimientos que tendrá lo desarrollado. Momento : Parámetros de una imagen que están relacionados con el tamaño, la posición, la orientación y la forma de ésta. Los momentos de denominan de orden p+q, siendo su fórmula: ( , ) ( ) ( ) ( , ) p q x y U p q x x y y f x y = − − ∑∑ Donde I(x,y) es el valor de la intensidad del píxel en la posición x,y. Multitouch: Técnica de interacción personacomputador. Esta tecnología consiste en una pantalla táctil que reconoce simultáneamente múltiples puntos de contacto y en un software asociado a ésta que permite interpretar dichas interacciones simultáneas. Tabletop: Mesa usada para la interacción persona– ordenador. La mesa consiste en una superficie transparente en la que se depositan los objetos para ser identificados, un proyector para mostrar una imagen con la que interactuar a través de los objetos y una cámara (vídeo, web,...) para detectar los objetos encima de la superficie. Umbralización : Acción que consiste en separar, en una imagen en escala de grises, el fondo del objeto, siempre y cuando el fondo y los objetos tengan sus niveles de gris agrupados en 2 niveles dominantes, estableciendo un umbral de separación que puede ser variable. XML: Extensible Markup Language (Lenguaje de marcas extensible). Formato usado para expre sar información estructurada a través de etiquetas de la manera más abstracta y reutilizable posible. Una etiqueta consiste en una marca hecha en el documento, que señala una porción de éste como un elemento. B.4 Modelo funcional Como ya se ha dicho, el modelo funcional se emplea para especificar el significado de las operaciones en el modelo de objetos. Para representar estas actividades se ha utilizado el diagrama de flujo de datos. B.4.1 Diagrama de flujo de datos A continuación se muestra el flujo de datos que circula entre los diferentes procesadores y elementos de Reactivision (ver fig 63-64-65-66-67). Los elementos que se encuentran coloreados en rojo son los que se han modificado: • Detector de fiduciales y blobs para el reconocimiento de los nuevos fiduciales y de los blobs Guillermo Navarro Sánchez 85 • Servidor TUIO para el envío de la nueva información. Y los coloreados en amarillo son los creados para el desarrollo del proyecto: • Servidor XML, para el envío de los ficheros de información XML. DFD Nivel 0: Figura 63 Diagrama de flujo de datos de Reactivision. Nivel 0. DFD NIVEL 1: Figura 64. Diagrama de flujo de datos de Reactivision. Nivel 1. DFD Nivel 2, detección de fiduciales, fingers y blobs: Reconocimiento visual de juguetes en una mesa de interacción tangible 86 Figura 65. Diagrama de flujo de datos de Reactivision. Nivel 1, detección de fiduciales, fingers y blobs La imagen umbralizada es segmentada, obteniendo las diferentes regiones que la forman. En la imagen segmentada se procede a la búsqueda de posibles fiduciales, fingers y blobs que posteriormente son validados para evitar falsos positivos o confusión entre objetos. Por último la información de cada uno de los objetos detectados es extraída. DFD Nivel 2, envío de mensajes TUIO: Guillermo Navarro Sánchez 87 Figura 66. Diagrama de flujo de datos de Reactivision. Nivel 1, envío de mensajes TUIO La información extraída de los diferentes objetos situados detectados es transmitida al servidor TUIO, que se encarga de procesarla y dividirla en información relativa a fiduciales, fingers y blobs. Por último los paquetes TUIO son creados y enviados a los juegos. DFD Nivel 2, envío información XML: Figura 67. Diagrama de flujo de datos de Reactivision. Nivel 1, envío información XML Reconocimiento visual de juguetes en una mesa de interacción tangible 88 La información extraída de los blobs y fiduciales pertenecientes a dibujos, es transmitida al servidor XML, que se encarga de procesarla y generar a partir de ella la cadena XML. Por último la información es enviada a los juegos. En la figura 68 se muestra el flujo de información entre el usuario y el interfaz gráfico. Los elementos que se encuentran en rojo son los que se han modificado para mostrar nueva información debido a las modificaciones. El detector de fiduciales y de blobs se ha modificado para que muestre por el display los identificadores de los nuevos fiduciales, las opciones de configuración del tamaño del folio para la captura de dibujos, así las opciones de configuración de los parámetros de los nuevos fiduciales. Figura 68 Diagrama de flujo de datos de la interfaz de Reactivision Guillermo Navarro Sánchez 89 Anexo C. Alternativas estudiadas En esta sección se explica las diferentes alternativas estudiadas de los algoritmos empleados en las distintas partes del proyecto, analizando sus ventajas y desventajas y porque finalmente fueron descartadas. C.1 Nueva colección de fiduciales A continuación se detalla en qué consisten los fiduciales de Reactivision lo que permitirá comprender mejor las limitaciones que estos conllevan, así las diferentes alternativas de reconocimiento de los nuevos fiduciales estudiadas y finalmente descartadas. C.1.1 ¿Qué son los fiduciales? En primer lugar se estudió en detalle los fiduciales estándar de Reactivision para poder entender las limitaciones que estos suponen. Los fiduciales son marcadores impresos que se colocan en la base de los juguetes para que puedan ser reconocidos (figura 69). El diseño de los fiduciales suele ser sencillo debido a la necesidad de que un ordenador pueda detectarlos de manera rápida. Por otra parte esta sencillez permite que pequeñas variaciones en el diseño puedan generar un gran número de fiduciales. Los fiduciales utilizados son siempre en blanco y negro, ya que como se ha indicado se utiliza luz infrarroja para iluminar el prototipo y si los fiduciales fueran de colores, no podrían ser reconocidos. Figura 69 Juguetes identificados con fiduciales. Los fiduciales que Reactivision interpreta tienen forma de ameba, ya que han sido diseñados para optimizar la distancia entre los contornos negros y blancos para que la cámara los detecte bien, usando círculos, que pueden ser concéntricos. Estos círculos proporcionan una orientación que puede ser usada en el procesado de la información [CH09]. Este diseño en Reconocimiento visual de juguetes en una mesa de interacción tangible 96 conectividad 8-vecina pero no 4 vecina. En la figura 79 se muestra como se vuelve al pixel de comienzo sin haber encontrado todos los píxeles del contorno. Figura 79 Tratamiento erróneo del contorno por el algoritmo de Theo Pavlidis En la figura 80 se observa como este algoritmo supera sin problema las limitaciones del algoritmo anteriormente explicado, encontrando todos los píxeles que forman el contorno del objeto y por tanto demostrando que con conexión 4-vecina también funciona. Figura 80 Contorno correctamente tratado por el algoritmo de Moore Guillermo Navarro Sánchez 97 Por los errores detectados en los algoritmos se decidió finalmente implementar el algoritmo de Moore, explicado en el capítulo 3, el único que no presentó ningún problema durante sus pruebas. C.2.1.1 Construcción de segmentos del contorno Para la segunda fase, es decir, la elección de los píxeles que finalmente forman el contorno y la construcción de los segmentos de éste, se estudiaron varios algoritmos basados en filosofías distintas. La primera filosofía estudiada fue la de aproximación poligonal, esta consiste en aproximar un contorno mediante el uso de un polígono. La aproximación será más exacta cuanto mayor sea el número de segmentos del polígono utilizado. El objetivo de esta técnica consiste en emplear el menor número posible de segmentos de tal manera que no se pierdan características esenciales del contorno. El primer algoritmo dentro de esta filosofía estudiado fue el algoritmo de fusión, se trata de ir ajustando los píxeles del contorno mediante una recta hasta que el error cometido en el ajuste supere un umbral preestablecido. Entonces, se almacenan los parámetros de la recta obtenida y se repite el proceso con los píxeles siguientes del contorno hasta que se hayan tratado todos. Al terminar el proceso, las intersecciones de las rectas adyacentes son los vértices del polígono (figura 81). Figura 81 Ejemplo de aproximación mediante la técnica de fusión El principal problema que presenta esta técnica es que los vértices generados no suelen corresponder con los vértices reales del contorno en especial con los que forman las esquinas. El segundo algoritmo de este tipo estudiado fue la de división recursiva, esta consiste en dividir sucesivamente un segmento en dos hasta que se satisfaga un determinado criterio, como por ejemplo, que la distancia de los puntos de un tramo del contorno al segmento que los aproxima no sobrepase una distancia determinada. En caso de que la sobrepasen, el punto más lejano es considerado nuevo vértice donde se subdivide el segmento en dos. A continuación se muestra un ejemplo del proceso seguido (figura 82). Reconocimiento visual de juguetes en una mesa de interacción tangible 98 Figura 82 Proceso seguido en el método de división recursiva. Este método tiene la ventaja de que detecta bien las esquinas del contorno, sin embargo tiene una alta sensibilidad al ruido en la imagen y que si el contorno contiene concavidades el proceso se hace más complicado. Otro tipo de algoritmos estudiados fueron los de representación polar. La idea es representar el contorno como una función polar, para ello se calcula un punto característico del interior del contorno, por ejemplo el centro de masas, y a partir de él representar la distancia de cada punto del contorno a dicho centro. Este método posee el inconveniente de ser muy sensible a la posición del centro, de esta manera cualquier error o perturbación en el centro se refleja en el cálculo del contorno. Finalmente se estudiaron algoritmos de códigos de cadena, estos se usan para representar la frontera en base a un conjunto de segmentos, de una longitud y dirección específica, conectados entre sí. Por lo general, esta representación está basada en segmentos de 8 direcciones. El procedimiento consiste en asignar una rejilla a la imagen y asignar a cada pixel de la frontera el nodo de la rejilla que se encuentre más cerca de él. Finalmente a partir de estos nodos, se crea un código que indica la dirección de los segmentos que forman el contorno. En la figura (83) se puede ver un ejemplo de los diferentes pasos seguidos en la técnica de cadena. Guillermo Navarro Sánchez 99 Figura 83 Proceso seguido en el algoritmo de cadena. Debido a los problemas que presentaban cada uno de los algoritmos así como su dificultad de implementación. Se decidió utilizar finalmente una simplificación de la técnica de cadena, en la que solo se usa la primera parte de esta, es decir la obtención de los nodos. La formación de los segmentos fue diseñada por completo en este PFC (capítulo 3). C.3 Protocolo de comunicación Para superar las limitaciones de comunicación expuestas en el capítulo 4, en un principio se estudió la utilización de memoria compartida entre Reactivision y los juegos en Flash. Esta técnica haría que la velocidad se incrementase considerablemente, ya que ambos programas estarían trabajando sobre el mismo espacio de memoria y podrán evitarse los problemas de bloqueo con técnicas de exclusión mutua. Se procedió al estudio de las herramientas disponibles para la implementación de esta solución. Se partía del problema de que cada uno de las dos partes estaba implementada en lenguajes diferentes, Reactivision en C++ y los juegos en ActionScript (Flash). Tras buscar información sobre memoria compartida, se encontró que existía una API para C sobre Windows (Windows Api) que permitía el trabajo con memoria compartida. Esta API permitía crear un espacio de memoria compartida por varios procesos que podían acceder a ella de manera excluyente, es decir para que no hubiese problemas de accesos o condiciones de carrera, los diferentes procesos que quisiesen acceder a este espacio de memoria, deberían utilizar mecanismos de sincronización como semáforos, eventos o algún mecanismo de exclusión mutua para que dos procesos no puedan acceder a la vez al espacio de memoria compartida. Reconocimiento visual de juguetes en una mesa de interacción tangible 100 Sin embargo no se encontró ninguna API o recurso para utilizar memoria compartida con ActionScript, por lo que finalmente se decidió buscar otras alternativas, finalmente implementando el protocolo basado en sockets y XML, explicado en el capítulo 4. Guillermo Navarro Sánchez 101 Anexo D. Otros frameworks y tabletops existentes. D.1 Frameworks A continuación se analizan las diferencias que presentan algunos frameworks existentes: Community Core Vision y Touchlib respecto a Reactivision. D.1.1 Community Core Vision Community Core Vision o CCV es un framework de código abierto de visión por computador desarrollado por el NUI Group [NUI, web]. Como Reactivision toma imágenes con una cámara y las analiza para detectar objetos en la superficie de un tabletop. A diferencia del framework utilizado en este proyecto, CCV se centra en la detección de eventos táctiles como el tocar la superficie o deslizar los dedos por encima del tabletop. También implementa el reconocimiento de objetos sin forma definida así como el reconocimiento de objetos identificados con fiduciales, sin embargo este tipo de reconocimiento no está todavía suficientemente desarrollado. Al igual que Reactivision puede comunicar los datos extraídos a otras aplicaciones a través de TUIO. Como se puede ver en la figura 84 la ventaja que CCV ofrece frente a Reactivision es la cuidada interfaz de usuario de la que viene provista, siendo esta la única ventaja frente a Reactivision. Figura 84 Interfaz de usuario de CCV Reconocimiento visual de juguetes en una mesa de interacción tangible 102 D.1.2 Touchlib Touchlib es una librería para aplicaciones multitáctiles que usen iluminación difusa [Touchlib, web]. Provee de detección y seguimiento de objetos planos sin ningún tipo de marcador. También provee funcionalidades limitadas de reconocimiento de fiduciales, pero no es su punto fuerte. A diferencia de Reactivision, sólo envía la información obtenida a aplicaciones programadas en C++. En la figura 85 se puede observar como la interfaz es muy similar al de Reactivision. Figura 85 Interfaz gráfica de touchlib. La utilización de cualquiera de estos dos frameworks en este PFC supondría el tener que volver a implementar funcionalidades como sería el reconocimiento de objetos planos en CCV y el reconocimiento de fiduciales en Touchlib. D.2 Tabletops A continuación se analizan algunos de los tabletops disponibles en el mercado y en trabajos de investigación, realizando una comparación con las funcionalidades desarrolladas en este PFC Guillermo Navarro Sánchez 103 D.2.1 Reactable Este tabletop [Reactable, web] es utilizado a modo de un instrumento musical electrónico colaborativo dotado de una interfaz tangible. Está inspirado en los sintetizadores modulares de los años sesenta. Fue desarrollado por el Grupo de Tecnología Musical de la Universidad Pompeu Fabra de Barcelona. Sus desarrolladores son los mismos que desarrollaron Reactivision. Cada fiducial, lleva asociado un sonido y cuando se coloca uno de estos fiduciales en el tabletop y Reactivision lo reconoce se emite el sonido. Además la orientación y distancia entre los diferentes objetos, permite variar la frecuencia a la que suena la música. La principal ventaja que presenta NIKvision sobre este tabletop reside en los diferentes juegos que implementa, ya que Reactable solo está destinado a la creación de música. En la figura 86 se muestra el tabletop en funcionamiento y la variación de frecuencia mediante la orientación y distancia de los objetos Figura 86 Parte superior del tabletop Reactable y como dependiendo de la distancia y rotación de los objetos se producen sonidos de diferentes frecuencias. D.2.2 Flux Digital Tabletop Tabletop con fines gráficos y de diseño de planos, que sirve de pizarra digital. Está diseñado para poder hacer trazos de gran precisión y por ello permite la utilización de lápices especiales y de diferentes tamaños, pudiéndose también ampliar la imagen. A su vez permite el manejo por parte de varias personas de forma simultánea. Cuando se sitúa la punta de uno de los lápices sobre la superficie del tabletop, éste la reconoce y va dibujando una línea, siguiendo el recorrido que se haga [LSPHBDP09]. Como puede verse en la figura 87 este tabletop está diseñado para el dibujo de precisión, como puede ser el dibujo de planos de arquitectura. En el tabletop usado durante el proyecto también permite el dibujo sobre la superficie, además permite el dibujo con pinceles Reconocimiento visual de juguetes en una mesa de interacción tangible 104 convencionales y el grosor del trazo dependerá de la presión que se ejerza con estos sobre la superficie de la mesa, lo que ofrece una mayor naturalidad en su manejo. Figura 87 Dibujo realizado en el tabletop Flux Digital D.2.3 U-Touch 103'' Multitouch Air Hockey Tabletop que simula el clásico juego de Air Hockey, que se puede encontrar en los salones recreativos [U-Touch, web]. La mesa detecta el punto de contacto de la mano con la superficie del tablero, siguiendo su trayectoria cuando se desplaza. Posteriormente realizan un cálculo de trayectoria y de los rebotes del disco cuando es golpeado para mostrar el movimiento del disco como si fuese real. La interacción se realiza a través de la detección de los dedos, funcionalidad que ya viene implementada en Reactivision. Este tabletop no presenta ninguna mejora respecto al utilizado en este proyecto. La detección de los dedos es la única función de reconocimiento y como ya se ha explicado en apartados anteriores, ésta ya viene implementada en Reactivision. En la figura 88 se muestra una imagen de la aplicación siendo usada por 2 personas. Guillermo Navarro Sánchez 105 Figura 88 Tabletop U-Touch 103'' Multitouch Air Hockey D.2.4 Lumisight Table Tabletop diseñado para la interacción simultánea de varios usuarios que permite la representación gráfica en las cuatro direcciones de la mesa, permitiendo así una mejor visión a cada uno de los usuarios (figura 89). Su funcionamiento se basa en la detección de los dedos de las manos así como de objetos identificados a través de marcadores [KHLNM06]. Como se observa en la figura 90 estos marcadores, se limitan a 4, lo que a diferencia con lo implementado en este proyecto, limita en gran medida el número de objetos a utilizar. Con respecto a la direccionalidad de la representación gráfica, NIKvision puede conseguir resultados similares, ya que esto depende de los juegos implementados en Flash. Al igual que el resto de tabletops mostrados, Lumisight Table solo está destinado a una tarea y las funcionalidades que implementa pueden ser replicadas en Reactivision. Figura 89 Interacción multi usuario en Lumisight table.