Date post: | 27-May-2015 |
Category: |
Investor Relations |
Upload: | agustin-hv |
View: | 1,835 times |
Download: | 5 times |
UNIVERSIDAD AUTÓNOMA DEL ESTADO DE HIDALGO
INSTITUTO DE CIENCIAS BÁSICAS E INGENIERÍA
ÁREA ACADÉMICA DE COMPUTACIÓN
CENTRO DE INVESTIGACIÓN EN TECNOLOGÍAS
DE INFORMACIÓN Y SISTEMAS
Mineral de la Reforma, Hidalgo. Mayo de 2012
Herramientas ARToolKit Implementadas en el
Proyecto de Realidad Aumentada TApir para
Sistemas Operativos de Código Abierto
QUE PARA OBTENER EL TÍTULO DE
LICENCIADO EN SISTEMAS COMPUTACIONALES
PRESENTA:
AGUSTÍN HERNÁNDEZ VÁZQUEZ
ASESOR:
M. EN C. ARTURO CURIEL ANAYA
M. EN C. MARIANO POZAS CÁRDENAS
Índice
Índice
Introducción ............................................................................................................ I
Organización ........................................................................................................ IV
Capítulo 1. Antecedentes de la Realidad Aumentada. ........................................ 1
1.1. Definiciones ..................................................................................................... 7
1.2. IEEE: Realidad Aumentada ............................................................................. 9
1.3. Ventajas y desventajas de la Realidad Aumentada ....................................... 18
1.4. Aplicaciones .................................................................................................. 19
1.4.1. Proyectos educativos .............................................................................. 19
1.4.2. Medicas .................................................................................................. 20
1.4.3. Entretenimiento ....................................................................................... 21
1.4.4. Simulación .............................................................................................. 22
1.4.5. Militar ...................................................................................................... 22
1.4.6. Publicidad ............................................................................................... 23
1.4.7. Aplicaciones Futuras ............................................................................... 24
Capítulo 2. Proyecto TApir. ................................................................................. 26
2.1. Breve explicación sobre el desarrollo ............................................................ 26
2.2. ARToolKit....................................................................................................... 31
2.2.1. Detección de marcadores mediante ARToolKit ....................................... 32
2.3. Librerías y software ...................................................................................... 34
2.3.1. OpenCV .................................................................................................. 35
2.3.2. GLUT ...................................................................................................... 36
2.3.3. OpenVRML ............................................................................................. 36
2.3.4. Python..................................................................................................... 37
2.3.5. Glade ...................................................................................................... 38
2.3.6. VRML ...................................................................................................... 39
2.2. Marcadores RA ............................................................................................. 40
Página
Índice
Capítulo 3. Integración del Proyecto TApir. ...................................................... 43
3.1. Identificación de factores ............................................................................... 43
3.2. Interfaz de TApir ............................................................................................ 46
3.3. Compilación de programas ............................................................................ 48
3.4. Ejecución de programas ................................................................................ 49
3.5. Integración de modelos tridimensionales complejos ...................................... 54
3.6. Árbol de dependencias .................................................................................. 57
3.7. Comandos y archivos .................................................................................... 58
Capítulo 4. Evaluación, Pruebas y Análisis de Resultados. ............................ 61
4.1. Pruebas TApir ................................................................................................ 63
Capítulo 5. Conclusión y Aplicaciones Futuras................................................ 69
5.1. Conclusiones ................................................................................................. 71
5.2. Tendencias y problemas ................................................................................ 73
Bibliografía y Referencias Electrónicas ............................................................ 75
Glosario ................................................................................................................ 81
Apéndice A. ............................................................................................................. i
A1. Manual para el uso de TApir ............................................................................ iii
A1.1. Requerimientos del Sistema ..................................................................... iv
A1.2. Instalación................................................................................................. iv
A1.3. Características de los algoritmos ............................................................... v
A2. Problemas de ejecución al lanzar TApir .......................................................... vi
Página
Índice
Apéndice B. ........................................................................................................... ix
B1. Acerca de TApir ................................................................................................xi
B2. Algoritmos TApir .............................................................................................. xii
Índice de Figuras
Figura 1. Head Mounted Display (HMD) para RV y RA. ............................................ 3
Figura 2. Sensorama "Cine de Experiencia”. ............................................................. 4
Figura 3. Videoplace: un sistema de reconocimiento de movimientos y gestos. ....... 4
Figura 4. Interacción virtual usando guantes y anteojos especiales. ......................... 5
Figura 5. RA basada en el conocimiento para el mantenimiento asistido. ................ 5
Figura 6. ARToolKit ejecutándose. ............................................................................. 6
Figura 7. Logo con el slogan "cam' on This is Augmented Reality". .......................... 6
Figura 8. Dinosaurio RA, portal web "Museo del Jurásico de Asturias" ................... 20
Figura 9. Tomografía cerebral con RA. .................................................................... 20
Figura 10. Juego de tiro al blanco de la portátil 3DS. .............................................. 21
Figura 11. Sistema de evaluación de partículas en movimiento. ............................. 22
Figura 12. Desplegar información en aeronaves. .................................................... 23
Figura 13. Visualizar productos armados de LEGO. ................................................ 23
Figura 14. Centro de RA situada en el mundo ficticio de Star Trek. ......................... 26
Figura 15. Realidad Aumentada en telefonía celular. ............................................... 26
Figura 16. Logo TApir. ............................................................................................. 29
Figura 17. Estructura del reconocimiento de marcadores. ....................................... 32
Figura 18 Logo Python. ............................................................................................ 37
Figura 19. Interfaz de Glade. ................................................................................... 39
Figura 20. Logo VRML. ............................................................................................ 39
Figura 21. Marcadores para el uso de RA. .............................................................. 41
Figura 22. Diagrama de bloques: Relación TApir, Python y Glade. ......................... 47
Página
Índice
Figura 23. Ejecución en terminal del comando make. .............................................. 50
Figura 24. Archivo sh. ............................................................................................... 51
Figura 25. Ejecución del programa simpletest.c. ...................................................... 52
Figura 26. Efecto de umbral para identificar marcadores. ........................................ 52
Figura 27. Posición del marcador. ............................................................................ 53
Figura 28. Integración de modelos complejos sobre video en directo. ..................... 56
Figura 29. Referencias indefinidas: simpletest.c. ..................................................... 58
Figura 30. Gedit es el editor para crear un makefile................................................. 58
Figura 31. Gedit mostrando un sh. ........................................................................... 60
Figura 32. Reconocimiento de marcador usando el filtro umbral. ............................ 64
Figura 33. Comparación entre software. .................................................................. 67
Figura 34. Interfaz TApir. ........................................................................................... iii
Figura 35. Marcadores utilizados por TApir. .............................................................. iii
Figura 36. Ventana para crear un lanzador. ............................................................... v
Figura 37. Terminar proceso usando una terminal. .................................................. vii
Figura 38. Ventana Añadir al panel. ......................................................................... vii
Figura 39. Forzar terminación. ................................................................................. viii
Figura 40. Lanzador o acceso directo a TApir. .......................................................... xi
Figura 41. Interfaz TApir. ........................................................................................... xi
Figura 42. Ventana "Acerca de TApir". ..................................................................... xii
Figura 43. Programa simpletest.c............................................................................. xii
Figura 44. Piloto de la interfaz final y prueba de conexiones. .................................. xiii
Figura 45. Algoritmo RA que reconoce un patrón y renderiza un grillo. ................... xiii
Figura 46. Renderizado de 2 modelos sobre video en directo. ............................... xiv
Figura 47. Mosca incrustada sobre video en directo ............................................... xiv
Página
Introducción
I
Introducción
Este documento hace referencia a un sistema basado en RA (Realidad
Aumentada) llamado TApir, en el cual se utilizó el lenguaje de programación C y
C++ en el compilador “GCC” (por sus siglas en ingles GNU Compiler Collection)
de la plataforma Linux con la distribución Ubuntu 9.04. El motivo para desarrollar
el proyecto en sistemas de código abierto es la flexibilidad del entorno; el sistema
pretende ser implementado en diferentes equipos con diferencias marcadas en
hardware, pero con el mismo software tanto en sistema operativo como con
dependencias.
El sistema surge de la iniciativa de comprender los sistemas aumentados es por
mi parte crear el nombre del proyecto y logotipo los cuales son atractivos para la
aplicación; pero la piedra angular es el desarrollo, ya que fue necesario identificar
los componentes principales que integran el sistema para posteriormente utilizar
las herramientas ideales que resuelvan los problemas que lleguen a presentarse,
de tal manera establecer las bases con la información recopilada y crear las
especificaciones del sistema.
El proyecto TApir es el resultado de un análisis que surge de varios software en el
entorno RA como es el caso de AMIRE y ATOMIC; los cuales son programas de
RA; el primero fue desarrollado en Visual Basic y el segundo en Java, ambos
utilizan librerías ARToolKit al igual que TApir. Las herramientas ARToolKit son la
mejor opción hasta el momento para el desarrollo de aplicaciones de este tipo,
además, al ser creadas en el lenguaje C y C++ es posible compilarlas en los
diferentes sistemas operativos existentes.
TApir esta integrado por varias herramientas, es evidente la presencia de
ARToolKit ya que es el alma del sistema, pero aun con ARToolKit solo es posible
lanzar los algoritmos desde una terminal con una robusta sintaxis; lo ideal es
invocar el algoritmo desde una interfaz para que un usuario logre visualizar el
contenido, y para ello se utilizo Python integrado a Glade además de scripts para
Introducción
II
invocar un algoritmo de RA con un click del mouse.
El sistema mantiene un entorno austero pero de fácil comprensión con la principal
característica de ser un software demostrativo, pero que manifiesta de manera
concreta diferentes algoritmos de la librería ARToolKit.
Objetivo General
Conocer y manejar aplicaciones de RA, ya que esta tecnología aun no es un
campo tan explorado como la realidad virtual (RV); dado a que la RA es un
área derivada de la virtual y en base a que el desarrollo de aplicaciones
virtuales se ha masificado para diversos usos, métodos o procesos; se pretende
analizar el uso y características que forman una aplicación de RA, mediante el
análisis y compilación de ARToolKit e implementar un desarrollo en donde sea
posible establecer una aproximación a este tipo de tecnología.
Objetivos específicos
Desarrollar una aplicación a manera de prueba de lo que es una
herramienta de RA utilizando ARToolKit.
Desplegar un entorno de RA donde se logre interactuar fácilmente;
usando herramientas graficas así como la disposición de hardware que
permita un buen desarrollo.
Examinar estructuras y fundamentos de las herramientas de RA
implementadas en ARToolKit.
Interpretar las librerías así como funciones y dependencias de las
herramientas utilizadas en ARToolKit.
Compilar librerías ARToolKit en el sistema operativo Ubuntu.
Identificar factibilidad de software para la creación de desarrollo.
Integrar software destacado.
Realizar pruebas sobre el software integrado.
Introducción
III
Definición del problema
En la actualidad las nuevas tecnologías son el próximo eslabón para alcanzar un
nivel tanto intelectual como social; las tecnologías son necesarias para el
desarrollo de un país es por eso que la falta de construcción de nuevas
tecnologías afecta a un país, pero la construcción de estas contribuye al desarrollo
de la economía. Queda entendido que el desarrollo de tecnología es una forma de
facilitar métodos o procesos a la sociedad.
La Realidad Aumentada es una tecnología que ya está repercutiendo en la
sociedad pero aún es un área de investigación y desarrollo, además, para que las
aplicaciones de Realidad Aumentada se logren ejecutar en medios informáticos es
necesario un hardware potente y dispositivos externos; sin embargo el principal
problema en el cual se centra este documento es compilar herramientas ARToolKit
(que son una colección de librerías para la creación de programas de RA) en un
sistema operativo de código abierto como Linux, añadiendo que en la plataforma
del sistema abierto es posible modificar fácilmente el entorno del escritorio a
diferencia de Windows o MacOS.
Es por ello que surge la iniciativa de evaluar la factibilidad de la creación de una
interfaz en un entorno GDM (gestor de ventanas que utiliza la distribución Ubuntu)
para crear una aplicación que demuestre el potencial de una aplicación de RA
como AMIRE o ATOMIC, aplicaciones que logran dar una perspectiva sobre RA de
una forma muy intuitiva hacia el usuario, pero además de crear el ambiente al
usuario, es necesario conocer que procesos se están ejecutando y que recursos
son necesarios para la vinculación entre hardware y software de la RA en
sistemas abiertos.
Introducción
IV
Justificación
Generar una aplicación para mostrar Realidad Aumentada (RA) en sistemas
operativos de código abierto (Ubuntu 9.04), mediante la modificación y
compilación de librerías ARToolKit, con la finalidad de aportar una herramienta
demostrativa de RA en sistemas opensource.
La aplicación en conjunto pretende demostrar el concepto de herramientas RA y
caracterizar los conflictos que puedan surgir para la creación del proyecto en base
a software; se pretende estudiar las distintas opciones a las que se puede acceder
según el nivel de hardware que se desee implementar.
Organización
La estructura de este documento está organizada en cinco capítulos, dos
apéndices y un apartado de referencias bibliográficas. La descripción de los
capítulos es la siguiente:
Capítulo 1. Antecedentes de la Realidad Aumentada.- Se exponen los
antecedentes de la RA, y se abordará en documentos sobre el estudio del arte de
Realidad Aumentada y funcionamiento de la misma.
Capítulo 2. Proyecto TApir.- En este capítulo se describe la creación del proyecto
TApir y el análisis de requerimientos así como el software para el desarrollo de la
aplicación.
Capítulo 3. Integración del Sistema TApir.- Este apartado está dedicado a
introducir y explicar los aspectos teórico-prácticos que deben considerarse para la
realización de una aplicación en RA. Es necesario mencionar que los métodos que
aquí se presentan son los que el autor de este documento considero idóneos para
Introducción
V
el proyecto, pero existen muchos otros métodos iguales de atractivos y
funcionales.
Capítulo 4. Evaluación, Pruebas y Análisis de Resultados.- Este capítulo presenta
los resultados obtenidos al implementar las herramientas para la creación del
sistema en RA.
Capítulo 5. Conclusión y Aplicaciones Futuras.- consumación acerca de las
tecnologías de RA así como respuesta al sistema implementado, además de
incluir las tecnologías Futuras o propuestas de software en el área de Realidad
Aumentada.
Referencias Bibliográficas y Electrónicas.- Fuentes de información de manos de
expertos, una colección de autores especializados en realidad aumentada, los
cuales son comentados en este documento.
Glosario.- Contiene palabras con su significado para facilitar el entendimiento de
conceptos de este documento.
Apéndice A. Manual de Usuario.- Esta sección se encarga de ayudar al usuario
para facilitarle el manejo de la herramienta desarrollada. Entre otros aspectos se
describen las características de la interfaz, la estructura necesaria de los archivos
de entrada y las funciones que se pueden realizar con el sistema.
Apéndice B. Colección de Escenas.- Exhibe una pequeña colección de imágenes
generadas con la herramienta TApir.
Capítulo 1. Antecedentes de la Realidad Aumentada
Capítulo 1.
Antecedentes de la
Realidad
Aumentada
Capítulo 1. Antecedentes de la Realidad Aumentada
3
Realidad Aumentada en inglés “Augmented Reality”, es un campo de investigación
computacional que trata de combinar el mundo real con datos generados por
computadora, a diferencia de la Realidad Virtual que trata de introducir al usuario
en un mundo simulado. El campo de estudio principal trata sobre integrar
imágenes virtuales sobre video digitalmente procesado, para “aumentar” la
percepción del mundo real. Es necesario entender que la Realidad Virtual y
Realidad Aumentada han ido prácticamente de la mano.
El origen de la Realidad Aumentada es consecuencia directa de los estudios
generados por Ivan Sutherland, creador entre otras cosas de la primera interfaz
gráfica de usuario (GUI), padre del concepto mundo virtual y precursor de la
mayoría de las interfaces de comunicación que hoy se conocen. Este hombre por
sí solo merece un artículo, pero por ahora este documento solo se centrará en la
idea de su enorme importancia en el mundo de la informática.
En 1968, Ivan Sutherland, con la ayuda de su estudiante Bob Sproull,
construyeron lo que sería ampliamente considerado el primer visor montado en la
cabeza o “Head Mounted Display“ también llamado “HMD” por sus siglas en
inglés, para Realidad Virtual y Realidad Aumentada (ver Figura 1) era muy
primitivo en términos de Interfaz de usuario y realismo y el “HMD” usado por el
usuario era tan grande y pesado que debía colgarse del techo, y los gráficos que
hacían al ambiente virtual eran simples modelos de alambres [21].
Figura 1. Head Mounted Display (HMD) para RV y RA.
Capítulo 1. Antecedentes de la Realidad Aumentada
4
En 1950 Morton Heilig escribió sobre un “Cine de Experiencia”, que logrará
acompañar a todos los sentidos de una
manera efectiva integrado al espectador
con la actividad en la pantalla. Construyó
un prototipo llamado Sensorama (ver
Figura 2) en 1962 el cual incluía cinco
filmes cortos que permitían aumentar la
experiencia del espectador a través de sus
sentidos (vista, olfato, tacto, y oído) [35].
Myron Krueger dio el siguiente paso al crear en 1972 [15] Videoplace, un sistema
que permitía a los usuarios interactuar con objetos. Dicho sistema no incluía
sistemas informáticos, realmente
utilizaba tecnologías alternativas de
vídeo y sistemas de reconocimiento
de movimientos y gestos (ver
Figura 3) desarrollados por el
mismo Kruege.
Fue el primer artista que se centró
en la interactividad como un medio
para composición creativa. Fue el pionero del desarrollo de la participación
inalámbrica y corporalmente integral en los experimentos de telecomunicación
originados por computadora, y acuñó en 1973 el término "realidad artificial" para
aludir a las últimas manifestaciones de este tipo de tecnología. Ha recibido varios
premios entre los que se puede destacar el primer Golden Nica del Prix Ars
Electronic. Sus obras han tenido una gran difusión internacional, pasando por
museos de arte, galerías y congresos científicos.
Figura 3. Videoplace: un sistema de
reconocimiento de movimientos y gestos.
Figura 2. Sensorama "Cine de Experiencia”.
Capítulo 1. Antecedentes de la Realidad Aumentada
5
A finales de los 80 se popularizó el término Realidad Virtual por Jaron Lanier, cuya
compañía fundada por él creó los
primeros guantes y anteojos con es
posible ver en la Figura 4, los cuales
servían para la interacción de la
Realidad Virtual [20].
Haciendo un pequeño salto hasta 1990,
un investigador llamado Tom Caudell usó
el término "Realidad Aumentada" para
describir una pantalla que usarían los
técnicos electricistas de Boeing y que
mezclaba gráficos virtuales con la
realidad física, este sistema les permitiría aumentar la eficiencia de su trabajo al
facilitarles de alguna forma la operación sobre las tareas a realizar. Caudell fue
contratado para encontrar una alternativa a los tediosos tableros de configuración
de cables que utilizan los trabajadores. Salió con la idea de anteojos especiales y
tableros virtuales sobre tableros reales genéricos, es así que se le ocurrió que
estaba “aumentando” la realidad del usuario [33].
Steven Feiner, Blair MacIntyre y Doree Seligmann en 1992 realizan la primera
utilización importante de un sistema de Realidad Aumentada en un prototipo
llamado KARMA, presentado en una
conferencia y ampliamente citado en la
publicación “Communications of the
ACM” al siguiente año. El sistema ofrecía
mantenimiento para impresoras sin la
necesidad de un técnico para realizarlo,
en la Figura 5 se puede apreciar el
sistema en ejecución.
Figura 4. Interacción virtual usando guantes y
anteojos especiales.
Figura 5. RA basada en el conocimiento para el
mantenimiento asistido.
Capítulo 1. Antecedentes de la Realidad Aumentada
6
En 1999, Hirozaku Kato desarrolla ARToolKit [19] en el
HitLAB de la Universidad de Washington, una de las
aplicaciones de software libre más potente hasta la fecha
para la creación de aplicaciones en Realidad Aumentada.
En la Figura 6 se muestra el potencial de estas
herramientas.
Desde entonces, el desarrollo de plataformas de
aplicaciones de Realidad Aumentada no ha parado de
crecer y ha tenido especial relevancia en aplicaciones para
smartphones y móviles de última generación, con mejoras
significativas en la capacidad de procesamiento y en la calidad de las cámaras
integradas que permiten que las aplicaciones basadas en la Realidad Aumentada
tengan cada vez mayor robustez.
Para el año 2009 se crea el logo oficial de la Realidad Aumentada [5] con el fin de
estandarizar la identificación de la tecnología aplicada en cualquier soporte o
medio por parte del público general, en la Figura 7 se presenta el logo de la RA.
Figura 7. Logo con el slogan "cam' on This is Augmented Reality".
Figura 6. ARToolKit
ejecutándose.
Capítulo 1. Antecedentes de la Realidad Aumentada
7
1.1. Definiciones
La Realidad Aumentada es el término que se usa para definir una visión directa o
indirecta de un entorno físico del mundo real, cuyos elementos se combinan con
elementos virtuales para la creación de una realidad mixta a tiempo real. Consiste
en un conjunto de dispositivos que añaden información virtual a la información
física ya existente, es decir, añadir una parte sintética virtual a lo real; la principal
diferencia con la realidad virtual, puesto que no sustituye la realidad física, sino
que sobreimprime los datos informáticos al mundo real. Con la ayuda de la
tecnología (por ejemplo, añadiendo la visión por computadora y reconocimiento de
objetos) la información sobre el mundo real alrededor del usuario se convierte en
interactiva y digital. La información artificial sobre el medio ambiente y los objetos
pueden ser almacenados y recuperados como una capa de información en la parte
superior de la visión del mundo real.
La Realidad Aumentada explora la aplicación de imágenes generadas por
computadora en tiempo real a secuencias de video como una forma de ampliar el
mundo real. La investigación incluye el uso de pantallas colocadas en la cabeza,
un display virtual colocado en la retina para mejorar la visualización, y la
construcción de ambientes controlados a partir sensores y actuadores.
Caudell y Mizell en 1992 [4] definen a la RA como la capacidad de proyección o de
combinación de gráficos o de texto con imágenes del mundo real, esta es una
característica de la Realidad Aumentada, de la misma forma Barfield, Rosenberg y
Lotens en 1995 llegan a la misma definición. Feiner, MacIntyre, y Seligmann en
1993 se refieren a esta capacidad como "mejora de los conocimientos" del mundo.
Rekimoto [30] en 1997 a modo de ejemplo, nos comenta que un transmisor de
infrarrojos se puede colocar en un objeto de interés y una vez detectada por un
receptor de infrarrojos usado por una persona, la información sobre el objeto se
puede acceder a través de una base de datos y proyectarla directamente sobre el
objeto. Otros sistemas de sensores, tales como cámaras CCD, utilizando técnicas
Capítulo 1. Antecedentes de la Realidad Aumentada
8
de visión por computadora puede detectar los códigos de barras u otras
características de un objeto lo que permite la misma funcionalidad o aumento del
conocimiento.
Hay diferentes tipos de tecnologías de visualización portátil, que puede ser
utilizada para combinar los objetos del mundo real con imágenes generadas por
computadora para formar una escena aumentada. Los dos tipos principales de
sistemas de pantallas de visualización de apoyo a las computadoras portátiles y
de Realidad Aumentada se muestran a continuación.
Los sistemas ópticos. Estos sistemas permiten al observador ver el mundo
real directamente con uno o ambos ojos, utilizando gráficos por
computadora o superponer texto en el mundo real, a través de HMD o gafas
con un sistema óptico.
Los sistemas de vídeo. Estos sistemas se pueden utilizar para ver el video
en vivo de las escenas del mundo real, junto con gráficos de computadora o
el texto superpuesto. Además, utiliza visualización monocular (un ojo) o
binocular (dos ojos). El video consiste en mostrar secuencia de imágenes a
través de pantallas, las cámaras toman la secuencia de imágenes para
capturar el video, para posteriormente mostrárselo al usuario. Utilizando
técnicas de croma o luminancia, el equipo, mediante algoritmos, fusiona el
vídeo con la imagen virtual para crear un entorno de Realidad Aumentada
basada en video.
Hay dos definiciones comúnmente aceptadas de la Realidad Aumentada en la
actualidad.
Una de ellas fue dada por Ronald Azuma en 1997 [1]. La definición de Azuma dice
que la Realidad Aumentada:
Combina elementos reales y virtuales.
Es interactiva en tiempo real.
Capítulo 1. Antecedentes de la Realidad Aumentada
9
Está registrada en 3D.
Mientras que Paul Milgram y Fumio Kishino en su investigación “Virtuality
Continuum” [28] la describen como un continuo que abarca desde el entorno real a
un entorno virtual puro. En medio hay Realidad Aumentada (más cerca del entorno
real) y Virtualidad Aumentada (está más cerca del entorno virtual).
Recientemente, el término Realidad Aumentada se ha difundido por el creciente
interés del público en general.
1.2. IEEE: Realidad Aumentada
Las investigaciones en Realidad Aumentada tiene sus primeras aportaciones
desde 1992 de acuerdo con los registros de la IEEE; a continuación se describen
algunos proyectos, prototipos y aplicaciones en Realidad Aumentada.
En el documento llamado “La Realidad Aumentada: una aplicación sobre la
tecnología de pantallas de visualización frontal para los procesos de fabricación
manual” (Augmented reality: an application of heads-up display technology to
manual manufacturing processes) se pretende utilizar pantallas de visualización
las cuales puedan ser operadas con el movimiento de la cabeza con el diseño y
creación de prototipos mediante la implementación de “heads-up” (pantalla de
visualización frontal), “see-through” (ver a través de), “head-mounted display”
(casco de visualización frontal), “HMDset” (set de herramientas para visualización).
Combinando los sistemas “HMD” con la detección de posición de la cabeza y un
sistema de registro del mundo real, esta tecnología permite a la computadora
establecer un diagrama que superpone y estabiliza en una posición específica un
objeto del mundo real.
Capítulo 1. Antecedentes de la Realidad Aumentada
10
El desarrollo exitoso de la tecnología “HMDset” permitirá la reducción de costos y
mejoras de la eficiencia en muchas de las operaciones humanas que intervienen
en la fabricación de aeronaves, mediante la eliminación de las plantillas,
diagramas, y otros dispositivos de enmascaramiento. El desarrollo de esta
tecnología aun trae consigo problemas en el reconocimiento del movimiento de
cabeza así como las coordenadas precisas de los objetos con los que se va a
interactuar [9].
“Mundos virtuales para la visualización de la información” (Virtual worlds for
visualizing information) es un documento de Feiner S, en donde se crean mundos
virtuales con entornos generados por computadora creados por muestra de
acoplamiento en 3D y dispositivos de interacción para estaciones de trabajo con
gráficos de gran alcance.
Feiner comenta sobre el diseño de mundos virtuales que se están llevando a cabo
por el equipo de Columbia's Computer Graphics y User Interfaces Group Two; de
los temas principales de la investigación de este grupo son la explotación de una
verdadera interacción en 3D y dispositivos de pantalla para visualizar y manipular
los espacios ricos en información, además del uso de técnicas de inteligencia
artificial para automatizar la generación de gráficos.
Los proyectos de discusión son: dirección de los mundos virtuales para la
visualización de datos multivalentes, interfaces de usuario híbridos que combinan
2D y 3D, dispositivos de interacción y realidad aumentada en el que se anota un
mundo circundante físico con gráficos en 3D basados en el conocimiento. La
integración de realidades es evidente y la exploración en RA solo era hipotética
puesto que el proyecto estaba en discusión en 1992 [10].
“Realidad virtual y Realidad Aumentada en el diseño y fabricación de aeronaves”
(Virtual reality and augmented reality in aircraft design and manufacturing) trabajo
realizado por Mizell, D.W, el autor está trabajando en dos proyectos de
investigación en “Boeing Computer Services” que tienen que ver con la tecnología
Capítulo 1. Antecedentes de la Realidad Aumentada
11
de realidad virtual. La primera consiste en la importación de aeronaves de datos
CAD en un entorno de realidad virtual. Las aplicaciones incluyen una amplia parte
de las actividades de ingeniería y diseño, todo lo cual implica ser capaz de ver e
interactuar con la geometría CAD como si uno estuviera dentro de una maqueta
física real de la aeronave.
Con respecto a la tecnología que se exploró en el segundo proyecto como
"Realidad Aumentada"; esto implica el uso de “see-through head-mounted display”
(HMD) con una longitud focal óptica de 20 pulgadas, junto con la posición de “VR-
style” sistema de orientación/detección. El área de aplicación previsto es en la
manofactura: la superposición de diagramas o texto sobre la superficie de una
pieza de trabajo y la estabilización de coordenadas determinadas, de modo que la
información adecuada que necesita un trabajador de una fábrica para cada paso
de una operación de fabricación o montaje aparece en la superficie de la pieza
como si estuviera pintado en ella.
El problema más difícil de la Realidad Aumentada es el seguimiento del
movimiento, posición a largo plazo y sistemas de detección de la orientación es
por ello que no pueda funcionar en ambientes como una fábrica. Este requisito y
otros dan lugar a algunos problemas computacionales interesantes, como usuario
de registro y detección de posición mediante el procesamiento de imágenes [26].
El proyecto titulado “Telerobot controlado con Realidad Aumentada” (Telerobotic
control using augmented reality) por Milgram, P. Rastogi, A. Grodski, J.J se
propone una taxonomía para la clasificación de control humano mediado de los
sistemas de manipulación a distancia, basado en tres dimensiones: el grado de
autonomía de la máquina, el nivel de la estructura del medio ambiente a distancia,
y el grado de conocimiento, o modelabilidad, del mundo remoto. Para ciertos
ambientes no estructurados el modelo resulta ser un tanto difícil, un caso que se
haga para la manipulación a distancia por medio del director y de control del
agente, en lugar de telepresencia.
Capítulo 1. Antecedentes de la Realidad Aumentada
12
El conjunto de herramientas de Realidad Aumentada ARGOS que se presentan,
como un medio para reunir información cuantitativa de entrada, de forma
interactiva a la creación de un modelo parcial de un sitio de trabajo de forma
remota en vista 3D. Esta información se utiliza para que la programación fuera de
línea local por parte del manipulador, es decir, cuando el telerobot virtual este listo,
los comandos finales se transmitirán para su ejecución en el sistema de control
mandando respuesta al operador de su posición [27].
Por otro lado en el documento titulado “Dinámica de corrección de registro en los
sistemas de video basados en la Realidad Aumentada” (Dynamic registration
correction in video-based augmented reality systems) Bajura, M. Neumann, U
comienza a definir y pulir el concepto de RA: los sistemas de Realidad Aumentada
permiten a los usuarios interactuar con objetos reales y generados por
computadora, mostrando objetos 3D virtuales en el entorno natural de un usuario.
Las aplicaciones de esta potente herramienta de visualización incluyen una vista
previa propuesta de los edificios en su entorno natural, interactuando con
maquinaria pesada para los propósitos de la construcción o de formación de
mantenimiento, y la visualización de los datos médicos de pacientes, tales como el
ultrasonido. En todas estas aplicaciones, los objetos generados por computadora
deben ser visualmente registradas con respecto a los objetos del mundo real en
cada imagen que ve el usuario.
Si la aplicación no mantiene un registro preciso, los objetos generados por
computadora pueden parecer que flotan en el ambiente natural del usuario, sin
tener una determinada posición en el espacio 3D. EL error de registro parece ser
el desplazamiento observado en la imagen entre las posiciones reales y el destino
de los objetos virtuales [2].
El problema de lograr ubicar los objetos de la realidad y mezclarlos con los
virtuales se ha vuelto el principal problema es por eso que en la investigación
llamada “Representaciones de objetos afines por detección de marcos para
Capítulo 1. Antecedentes de la Realidad Aumentada
13
realidad aumentada” (Affine object representations for calibration-free augmented
reality) trabajo realizado por Kutulakos, K.N. Vallino, J, se describe el diseño e
implementación de un sistema de vídeo basado en Realidad Aumentada capaz de
superponer tres objetos gráficos tridimensionales en video en vivo de entornos
dinámicos. La característica clave del sistema es que está completamente
descalibrado: no utiliza ningún tipo de información métrica sobre los parámetros de
calibración de la cámara o la ubicación 3D ni en las dimensiones de los objetos del
entorno.
El único requisito es la capacidad de Rastrear a través de marcos por lo menos
cuatro puntos característicos, los cuales son especificados por el usuario en
tiempo de inicialización del sistema y cuyas coordenadas del mundo son
desconocidos. Este enfoque se basa en la siguiente observación: dado un
conjunto de cuatro o más puntos 3D escalonados y la proyección de todos los
puntos en el conjunto, se puede calcular como una combinación lineal de las
proyecciones de sólo cuatro de los puntos.
Aprovechado esta observación: las líneas de seguimiento y fudicial points en la
velocidad de fotogramas, la representación de objetos virtuales en una línea no
euclidiana, contado con la continuidad en el marco de referencia que permite hacia
la proyección una aproximación como una combinación lineal de la proyección de
los fudicial points. Ahora ya no depende de realizar cálculos o reconocer todo el
entorno ya que haciendo la detección de marcos, mediante el uso de puntos
característicos es posible la incrustación de elementos en 3D [16].
El sistema de detección de marcos dio un gran avance en el área de RA y en el
documento “Adición de conocimiento a través de la animación en la realidad
aumentada” (Adding insight through animation in augmented reality) Feiner, S.K
hace un análisis a la mayoría de los sistemas de realidad virtual que han sido
publicados en los últimos diez años y revela que el uso del casco virtual bloquea al
usuario del mundo real y la manera más eficaz de inmersión en un entorno de
síntesis es la RA.
Capítulo 1. Antecedentes de la Realidad Aumentada
14
Feiner afirma que estos sistemas tienen un enorme potencial para ciertas
aplicaciones que van desde juegos de video hasta la investigación científica. Por
otra parte, la creencia de que los mundos virtuales más potentes y comunes en
un futuro reemplazarán al mundo real, sino que lo aumentaran con información.
A este enfoque se le llama Realidad Aumentada y fue por primera vez con Ivan
Sutherland, quien, hace más de un cuarto de siglo, desarrolló el primer casco
virtual. Sutherland, cuando termino su sistema, presentaba gráficos al usuario en
un par de pantallas estéreo, que el usuario llevaba en la cabeza. La imagen
producida por la muestra se combinó con la opinión del usuario del mundo y
divisores de haz de espejo. Su sistema de seguimiento 3D determinaba la posición
y orientación de la cabeza del usuario. Esto permitió al sistema cambiar el punto
de vista, basándose en la dirección en la que el usuario esta enfocándose [8].
Los avances en RA siguen con el proyecto “Un rastreador óptico para Realidad
Aumentada y computadoras portátiles” (An optical tracker for augmented reality
and wearable computers) Kim, D. Richards, S.W. Caudell, T.P que expone dentro
de su documento que la realidad aumentada proporciona a trabajadores de fábrica
y a personal laboral y contacto con la información visual superpuesta a la célula de
trabajo para ayudar en el desempeño de sus tareas.
Esta aplicación de la tecnología de realidad virtual requiere una alta precisión,
portabilidad, robusto mecánicamente y ligero de seguimiento en los sistemas que
operan en un entorno muy ruidoso. En el documento se describe un prototipo de
sistema de seguimiento en cabeza, actualmente en fase de desarrollo y pruebas,
que se basa en un pequeño detector sin cristalino, de cuatro células, un conjunto
de ubicación fija y balizas ópticas, que potencialmente pueden cumplir estos
requisitos [17].
Thomas, B. Demczuk, V. Piekarski, W. Hepworth, D. Gunther, B desarrollan un
sistema informático portátil con la Realidad Aumentada para apoyar la navegación
terrestre (“A wearable computer system with augmented reality to support
Capítulo 1. Antecedentes de la Realidad Aumentada
15
terrestrial navigation”) hasta la fecha la Realidad Aumentada normalmente se
opera sólo en una pequeña área definida. Este documento informa la investigación
sobre la expansión de Realidad Aumentada para ambientes al aire libre.
El proyecto consiste en proporcionar ayudas visuales para la navegación a los
usuarios. Un sistema informático portátil con una pantalla, brújula digital y un GPS,
herramientas que se utilizan para proporcionar señales visuales al realizar una
tarea de orientación estándar. En el artículo se reportan los resultados de una
serie de ensayos utilizando un equipo fuera de la plataforma portátil, equipado con
un paquete personalizado de construcción de software de navegación, llamado
"mapa sombrero" [34].
“Realidad Aumentada en telerobótica a través de Internet usando múltiples puntos
de vista monoscópica” (Augmented reality in Internet telerobotics using multiple
monoscopic views) Friz, H. Elzer, P. Dalton, B. Taylor, K crean Usher, un interfaz
de usuario para un telerobot de Internet que se ha desarrollado. En la interfaz se
superponen varias imágenes monoscópicas (imágenes proporcionadas por un
display en las que el usuario sólo dispone de entradas de profundidad
monoculares) del medio ambiente del robot con una visualización de tres
dimensiones con 5 grados de libertad. El operador arrastra los elementos de la
visualización de imágenes a un dispositivo de señalización adicionales para
obtener claves de profundidad, el tamaño de la medida, la ubicación y orientación
de los objetos.
Friz, H. Elzer, P. Dalton, B. Taylor, K describen el diseño de la interfaz desde la
perspectiva de la interacción humano-computadora. El diseño de la interfaz de
usuario ha sido desarrollado mediante la aplicación del enfoque ecológico de la
percepción visual a una visualización de datos de los 5 grados de libertad. Esto
lleva a una estructura simple similar a un palillo, que se puede utilizar para
especificar una pose en el espacio 3D utilizando solamente dispositivos de entrada
de dos dimensiones. La interfaz de usuario se implementa como un applet de Java
Capítulo 1. Antecedentes de la Realidad Aumentada
16
y se puede utilizar para controlar telerobot de Australia de la página web en
http://telerobot.mech.uwa.edu.au/ [12].
“Sistemas de Realidad Aumentada para aplicaciones médicas” (Augmented reality
systems for medical applications) Son-Lik Tang, Chee-Keong Kwoh, Ming-Yeong
Teo Ng Wan Sing y Keck-Voon Ling aportan sobre la realidad aumentada
aclarando que es una tecnología en la que se superpone una imagen generada
por computadora en la visión del usuario del mundo real, dando al usuario
información adicional generada por el modelo de computadora. Esta tecnología es
diferente de la realidad virtual, en el que se sumerge al usuario en un mundo
virtual generado por la computadora. Por el contrario, el sistema RA acerca el
"mundo" de los usuarios al aumentar el entorno real con objetos virtuales. Usando
un sistema de RA, la vista del usuario del mundo real es mayor. Esta mejora
puede ser en forma de etiquetas, modelos en 3D prestados, o las modificaciones
sombra.
Son-Lik Tang, Chee-Keong Kwoh, Ming-Yeong Teo, Ng Wan Sing y Keck-Voon
Ling revisan algunas de las investigaciones con los sistemas de RA, las
configuraciones de sistema básicos, los enfoques de registro de la imagen y los
problemas técnicos relacionados con la tecnología RA que son la luz y el grado de
calibración libre en el ambiente. También menciona algunos requisitos para un
sistema de RA intervencionista, que puede ayudar a los cirujanos mediante la guía
de un plan quirúrgico en un sistema aumentado [32].
El método de reconocimiento de fudicial points de Kutulakos, K.N. Vallino, J.R
agrega el uso de marcos para la orientación, en el documento “Calibration-free
augmented reality” (Detección de marcos para la Realidad Aumentada) hasta
ahora han tenido en cuenta los requisitos necesarios para la superposición de
objetos gráficos en tres dimensiones sobre vídeo en directo.
Se describe un nuevo enfoque de la Realidad Aumentada de vídeo basado en que
evita los requisitos que en 1992 se trazaron: no utiliza ningún tipo de información
Capítulo 1. Antecedentes de la Realidad Aumentada
17
métrica sobre los parámetros de calibración de la cámara o la ubicación sobre las
dimensiones de los objetos del entorno 3D. El único requisito es la capacidad de
rastrear a través de marcos, al menos cuatro fudicial points que son especificados
por el usuario durante la inicialización del sistema y cuyas coordenadas del mundo
son desconocidos.
El enfoque de Kutulakos se basa en la siguiente observación: dado un conjunto de
cuatro o más puntos no coplanares 3D, la proyección de todos los puntos en el
conjunto se puede calcular como una combinación lineal de las proyecciones de
sólo cuatro de ellos. Aprovechando esta observación: las regiones de seguimiento
y el color de los fudicial points en la velocidad de fotogramas, y que representan
objetos virtuales en un no euclidiana, contado con la continuidad de referencia que
permite su proyección, se calcula como una combinación lineal de la proyección
de los fudicial points.
Los resultados experimentales en dos sistemas de Realidad Aumentada, basada
en un monitor y una cabeza montada, demuestran que el enfoque es fácilmente
realizable, impone un mínimo de requisitos de cómputo y hardware además de
ejecutarse en tiempo real, incluye vídeo que se superpone incluso cuando los
parámetros de la cámara varían dinámicamente [18].
DiVerdi, S. Nurmi, D. Hollerer, T presenta el documento “Un marco genérico para
las aplicaciones de interacción en entornos 3D y RA” originalmente llamado “A
framework for generic inter-application interaction for 3D AR environments”. El
frame o cuadro en español, se construye dentro de una ventana en torno a las
herramientas ARToolKit. La interfaz ofrece a los usuarios un mecanismo visual
simple para establecer comunicaciones entre las aplicaciones de un modo
genérico.
La interfaz que ofrece DiVerdi, S. Nurmi, D. Hollerer está diseñada para facilitar el
desarrollo y la máxima flexibilidad para el usuario final. El frame mostrará
aplicaciones en 3D y sus interacciones en el frame, lo que demuestra las nuevas
Capítulo 1. Antecedentes de la Realidad Aumentada
18
posibilidades creadas por las interfaces 3D. Se centra en clasificar las funciones
de las aplicaciones de estas interacciones, que sirva para orientar el desarrollo.
Finalmente, se discuten las posibilidades futuras de las aplicaciones e
interacciones dentro de ese frame [7].
Existen aportaciones importantes de la RA como lo es el software pero sobre este
destacan los métodos y técnicas que se emplean para la misma, las cuales son
diversas y cada una contiene su grado de complejidad, así como su lógica en
cuanto a resolver la detección de formas e incrustar objetos a la realidad, en
principio parece ser que la RA simple, pues a algunas personas no se les hace
muy diferente a los efectos de cine o televisión, pero no es así la RA no es una
tarea fácil los procesos que se necesitan son muy elevados computacionalmente
hablando, además que a diferencia de la televisión o el cine no es video editado
,sino que, se trata de integrar información adicional a la realidad sin la necesidad
de algún editor o postproducción ya que todo se hace en tiempo real, pero aun con
software con aportaciones importantes las aplicaciones son visualizadas en
dispositivos externos, aunque los diversos componentes son necesarios, el efecto
que logra la RA es muy impresiónate a pesar la interacción con pantallas.
1.3. Ventajas y desventajas de la Realidad
Aumentada
Ventajas:
Enriquece y mejora la experiencia del usuario,
Mejora el conocimiento de un entorno y proporciona un aumento del
mismo,
Permite al usuario sumergirse en información adicional con la que
cuenta en su entorno,
Se adapta al usuario en función del tiempo y profundidad en el
mundo real,
Es una herramienta innovadora para realizar campañas de
Capítulo 1. Antecedentes de la Realidad Aumentada
19
Marketing. Esta tecnología permite una gran interactividad entre el
usuario y el producto y ofrece a las empresas una herramienta muy
potente para que sus consumidores potenciales jueguen con los
productos y disfruten de una experiencia única.
Desventajas:
Altos costos en cuanto a hardware,
Actualmente el mejor método es de detección de marcas para
realizar aplicaciones RA, por esto es necesario ubicarse en un
ambiente en condiciones a los requerimientos del sistema; ya que es
necesario un lugar con buena iluminación puesto que es un factor
importante para reconocer las marcas y si no se cuenta con el
ambiente especificado la aplicación no alcanza su potencial,
Solo es posible visualizar el contenido RA en dispositivos externos,
esto es una limitante ya que la integración solo se hace a través de
una pantalla en una perspectiva ajena a la del usuario, pero existen
HMD en los cuales son muy útiles ya que dibujan sobre el casco del
usuario y en su perspectiva, solo que el equipo HMD es muy grande
aún.
1.4. Aplicaciones
La Realidad Aumentada ofrece infinidad de nuevas posibilidades de interacción,
las cuales hacen que esté presente en muchos y varios ámbitos, como son la
arquitectura, el entretenimiento, la educación, el arte, la medicina por mencionar
algunos.
1.4.1. Proyectos educativos
La idea básica de la Realidad Aumentada es superponer objetos virtuales en miles
de imágenes del mundo real para así "aumentar" la perspectiva del mundo.
Zagoranski, S. Divjak, S. presenta la primera experiencia con diseño e
Capítulo 1. Antecedentes de la Realidad Aumentada
20
implementación a un usuario, una herramienta en Realidad Aumentada que podría
servir como un laboratorio virtual interactivo.
El objetivo de la investigación de Zagoranski es implementar este sistema en los
procesos educativos.
La página del “Museo del Jurásico de Asturias” ofrece una serie de recursos en
realidad aumentada donde es
posible observar un dinosaurio el
cual se mueve, ruge, cambia la
perspectiva desde la que se le
observa y la cuenta con la posibilidad
de controlar sus movimientos con el
teclado, en la Figura 8 se puede ver
un dinosaurio del portal web.
1.4.2. Médicas
La aplicación de Realidad Aumentada en operaciones permitirá al cirujano
superponer datos visuales como por ejemplo tomografías o la delimitación de los
bordes limpios de un tumor, invisibles a simple vista, tal como se muestra en la
Figura 9, minimizando el impacto
de la cirugía de acuerdo a los
investigadores Son-Lik Tang,
Chee-Keong Kwoh, Ming-Yeong
Teo, Ng Wan Sing y Keck-Voon
Ling.
La RA superpone en tiempo real
la reconstrucción 3D de las
estructuras internas del paciente sobre vídeo en directo, además supone
reducción de costos [22] (entre 1000 y 5000 dólares) y reducción en el tiempo de
Figura 8. Dinosaurio RA, portal web "Museo del Jurásico de Asturias"
Figura 9. Tomografía cerebral con RA.
Capítulo 1. Antecedentes de la Realidad Aumentada
21
intervención. Las tomografías podrían ser mas accesibles ya que el hardware es
de menor costo que los equipos médicos.
1.4.3. Entretenimiento
Lyu, M.R. King, I. Wong, T.T. Yau, E y Chan, P.W. [23] Comentan que la tecnología
para la composición digital de la animación con escenas reales, es traer una
nueva experiencia de entretenimiento digital a los espectadores. La realidad
aumentada es una forma de interacción hombre-máquina. La característica de la
tecnología de RA es presentar información auxiliar en el campo de visión de un
individuo de forma automática sin intervención humana.
El efecto es similar a la composición por procesamiento digital de imágenes
animadas con escenas reales. Para conseguir una nueva experiencia de realidad
aumentada, los autores apoyan la creación de aplicaciones de RA para el
entretenimiento. Por otra parte, también están desarrollando nuevas formas de
seguimiento de marcadores más definidos, como por ejemplo el reconocimiento de
cabeza la humana y el seguimiento de la cara.
Nintendo ha desarrollado
aplicaciones con fines de
entretenimiento para su consola
portátil 3DS [29], las posibilidades
van desde mostrar cubos hasta un
juego de disparos en donde se
interactúa con movimiento y los
cuadros de RA, en la Figura 10 se
puede ver el juego de tiro al blanco.
Figura 10. Juego de tiro al blanco de la portátil 3DS.
Capítulo 1. Antecedentes de la Realidad Aumentada
22
1.4.4. Simulación
Malkawi, A. Srinivasan, R. Jackson, B. y Yun Yi Kin Chan [24] desarrollan un
sistema de Realidad Aumentada al que se le integró, con un motor de simulación
para facilitar la manipulación de datos y aumentar el control del medio ambiente
envolvente y un nuevo método intuitivo de la interacción humano-máquina.
La simulación de Malkawi, A. Srinivasan, R. Jackson, B. y Yun Yi Kin Chan se
utiliza para predecir los ambientes interiores y evaluar su respuesta a
determinadas condiciones internas y
externas, en la Figura 11 se puede
apreciar el registro de partículas
virtuales y objetos gráficos en el
espacio real. Para facilitar la
manipulación de datos de manera
eficiente, la simulación de
procesado de datos aumenta la
facilidad de control del medio
ambiente envolvente.
Un sistema de reconocimiento de gestos se integró con la realidad aumentada
para transformar la estructura de los datos en una descripción generada a través
de la cinemática hacia adelante y el cálculo de las posiciones del segmento y sus
ángulos de las articulaciones. Esto permitió dar resultados en tiempo real de las
interacciones entre los usuarios y el simulador.
1.4.5. Militar
En el campo militar [11], es posible desplegar información de mapas, localización
de los enemigos también la posibilidad de tener controlada en todo momento la
posición de sus compañeros, consultar mapas del terreno, calcular y adjudicarse
Figura 11. Sistema de evaluación de partículas en movimiento.
Capítulo 1. Antecedentes de la Realidad Aumentada
23
objetivos o enviar y recibir órdenes precisas. Otra aplicación de utilidad es para los
aviones de combate, sobre el parabrisas se proyecta toda la información necesaria
para el piloto ver Figura 12, que
se superpone sobre la vista
hacia el exterior, esto permite
seguir simultáneamente lo que
ocurre en el exterior del avión y
tener a la mano los indicadores
del avión sin desviar la mirada.
1.4.6. Publicidad
Existen diferentes campañas publicitarias que utilizan este recurso para llamar la
atención del cliente. Una de estas es el desarrollo de un sistema de marketing
para el E-commerce [6]. El sistema consta de un conjunto de señales especiales
además de la capacidad para calibrar una cámara y seguir el movimiento de
marcadores para presentar modelos de productos de ropa y accesorios. No hay
ningún hardware especial requerido para este sistema, excepto una cámara para
PC.
La compañía LEGO [25] también utiliza RA para sus productos, lego pensó en
darle al comprador una perspectiva mas elaborada de su producto, de tal manera
que, implemento en tiendas una pantalla
en donde un cliente muestra la caja de
LEGO y sobre esta se visualiza un
modelo del producto armado ver Figura
13, aunque en la caja hay una imagen del
producto armado, con la RA es posible
observarlo en diferentes ángulos y
perspectivas haciendo mas llamativo e
incitando a su compra. Figura 13. Visualizar productos armados de LEGO.
Figura 12. Desplegar información en aeronaves.
Capítulo 1. Antecedentes de la Realidad Aumentada
24
1.4.7. Aplicaciones Futuras
La Realidad Aumentada puede tener más ejemplos de modelos informáticos de
lugares y sonidos relacionados con la realidad física, así como determinar la
situación exacta de cada usuario, y ser capaz de mostrar al usuario una
representación realista del entorno que se ha añadido virtualmente. Es muy
importante determinar la orientación y posición exacta del usuario, sobre todo en
las aplicaciones que así lo requieran: uno de los retos más importantes a la hora
de desarrollar proyectos de Realidad Aumentada son los elementos visuales ya
que deben estar coordinados a la perfección con los objetos reales, puesto que un
pequeño error de orientación puede provocar un desalineamiento perceptible entre
los objetos virtuales y físicos.
En zonas muy amplias los sensores de orientación usan magnetómetros,
inclinómetros, sensores inerciales, entre otros que pueden verse afectados
gravemente por campos magnéticos, y por lo tanto se ha de intentar reducir al
máximo este efecto. Sería interesante que una aplicación de Realidad Aumentada
lograra localizar elementos naturales (como árboles o rocas) que no hubieran sido
catalogados previamente, sin que el sistema tuviera que tener un conocimiento
previo del territorio.
Como reto a largo plazo es posible sugerir el diseño de aplicaciones en los que la
Realidad Aumentada fuera un poco más allá, de lo que es llamado "Realidad
Aumentada retroalimentada", esto es, que la "descoordinación" resultante del uso
de sensores de posición/orientación, fuera corregida midiendo las desviaciones
entre las medidas de los sensores y las del mundo real. Imagina un sistema de
Realidad Aumentada que partiendo de pares de imágenes estéreo obtenidas de
dos cámaras solidarias al usuario (head-mounted) y de la posición del mismo,
fuera capaz de determinar la posición y orientación exacta del que mira.
Es importante señalar que la Realidad Aumentada es un desarrollo costoso de la
Capítulo 1. Antecedentes de la Realidad Aumentada
25
tecnología. Debido a esto, el futuro de la RA depende de si esos costos se pueden
reducir de alguna manera. Si la tecnología RA se hace asequible, podría ser muy
amplia, pero por ahora las principales industrias son los únicos compradores que
tienen la oportunidad de utilizar este recurso. En el futuro podríamos encontrar
aplicaciones de este estilo:
• Aplicaciones de multimedia mejoradas, como pseudopantallas holográficas
virtuales, sonido envolvente virtual de cine, "holodecks" virtuales (que
permiten imágenes generadas por computadora para interactuar con
artistas en vivo y la audiencia).
• Conferencias virtuales en estilo "holodeck" (ver Figura 14) como en la
serie de televisión Star Trek.
• Sustitución de teléfonos celulares (ver Figura 15) y pantallas de navegador
de coche inserción de la información directamente en el medio ambiente.
Por ejemplo, las líneas de guía directamente en la carretera.
• Plantas virtuales, fondos de escritorio, vistas panorámicas, obras de arte,
decoración, iluminación, la mejora de la vida cotidiana, entre otros.
• Con los sistemas de RA se puede entrar en el mercado de masas, viendo
los letreros virtualmente, carteles, señales de tráfico, las decoraciones de
Navidad, las torres de publicidad y mucho más. Éstos pueden ser
totalmente interactivos, incluso a distancia [31].
Capítulo 1. Antecedentes de la Realidad Aumentada
26
Figura 14. Centro de RA situada en el mundo ficticio de Star Trek.
Figura 15. Realidad Aumentada en telefonía celular.
Capítulo 2. Proyecto TApir
Capítulo 2.
Proyecto TApir
Capítulo 2. Proyecto TApir
29
2.1. Breve explicación sobre el desarrollo
Es importante evaluar las aplicaciones de RA con la construcción de una
herramienta que logre acercar al conocimiento de esta tecnología además de
caracterizar que problemas pueden surgir al desarrollarla. Es por esto que surge la
iniciativa de desarrollar el proyecto TApir; el proyecto pretende alcanzar las
tecnologías de aumento del conocimiento con la creación de un software
demostrativo el cual pueda vincular la RA y el
usuario final, la aplicación requiere demostrar
los diferentes algoritmos de la librería
ARToolKit; con la finalidad de que el
desarrollo desemboque como un software de
RA, nace la creación del proyecto y logotipo
para solidificarlo (ver Figura 16).
TApir recibe el nombre de una canción llamada “Tapir's Flown Away” de la banda
de Noise Japonés Melt Banana, fue por esta canción y por una parte de la letra
que dice lo siguiente: ”close to the fact, fill-up 50/50” la traducción de esa frase es
“cerca de la realidad, hasta un 50/50” por ello se le llamo al proyecto TApir; que
es lo que la RA representa 50% es la realidad y el otro 50% es lo virtual; y para
hacer más atractivo el nombre se colocaron las dos primeras letras en mayúscula
las cuales representan T.- traspasar y A.- aumentar.
Fue necesario para la investigación y desarrollo del proyecto TApir:
Desarrollar una aplicación a manera de prueba de lo que es una
herramienta de RA utilizando ARToolKit.
Desplegar un entorno de RA donde se logre interactuar fácilmente;
usando herramientas graficas así como la disposición de hardware que
permita un buen desarrollo.
Examinar estructuras y fundamentos de las herramientas de RA
Figura 16. Logo TApir.
Capítulo 2. Proyecto TApir
30
implementadas en ARToolKit.
Interpretar las librerías así como funciones y dependencias de las
herramientas utilizadas en ARToolKit.
Compilar librerías ARToolKit en el sistema operativo Ubuntu.
Identificar factibilidad de software para la creación de desarrollo.
Integrar software destacado.
Realizar pruebas sobre el software integrado.
Los puntos anteriores son conjunto de acciones que se realizaron para que el
proyecto culminara como TApir, hay que destacar que en principio el proyecto no
tenia nombre, pero una vez que fue tomando bases decidí tomar en serio el
proyecto para plasmar al final una aplicación, que aunque austera, formara parte
de los entornos de RA.
El desarrollo e implementación de la herramienta en RA pretende generar
antecedentes para programadores, diseñadores gráficos y desarrolladores en el
campo de la realidad virtual que en un futuro contemplen realizar y/o enfocarse en
la tecnología o herramientas de RA; la cual se encuentra en crecimiento como una
forma alterna para la realidad virtual ya que amplifica el nivel de interacción con el
usuario, además, de lograr el grandioso efecto de mezclar objetos en 3D con la
realidad.
Es por ello que por medio de un análisis de las herramientas y/o aplicaciones de
esta tecnología se planea desarrollar un entorno de RA en donde se logre
interactuar con estas aplicaciones, usando herramientas graficas así como la
disposición de hardware que permita el buen desarrollo del proyecto.
Para el desarrollo del proyecto, el sistema operativo en el que se elabore no
depende mucho ya que es posible compilar las herramientas de RA en cualquier
sistema operativo, puesto que se usarán las librerías ARToolKit, pero esta
situación no es igual con en el hardware ya que el rendimiento de los
componentes dependen mucho para la realización de una aplicación de RA.
Capítulo 2. Proyecto TApir
31
TApir utiliza el método de detección de marcos con el reconocimiento de los
fudicial points ya que es la mejor opción para desarrollar una herramienta de este
tipo, además de que la ARToolKit contiene de ante mano este método; el proyecto
es la suma de software tanto de diseño como de desarrollo, la modularidad fue la
clave para concretar el sistema; a continuación se describen las herramientas que
se utilizaran para el proyecto TApir.
2.2. ARToolKit
ARToolKit es una biblioteca de software para la creación de aplicaciones de
Realidad Aumentada. Estas aplicaciones implican la superposición de imágenes
virtuales en el mundo real.
Una de las principales dificultades en el desarrollo de aplicaciones de Realidad
Aumentada es el problema de seguimiento del punto de vista de los usuarios, con
el fin de saber qué punto de vista tiene el usuario, para dibujar las imágenes
virtuales frente a él, la aplicación necesita saber dónde está el usuario en el
mundo real, ARToolKit utiliza algoritmos de visión por computadora para resolver
este problema, las bibliotecas de video ARToolKit calculan la posición de la
cámara y orientación relativa a los marcadores en tiempo real. Esto permite un
fácil desarrollo de una amplia gama de aplicaciones de Realidad Aumentada.
Algunas de las características de ARToolKit son:
Posición de la cámara: seguimiento/orientación.
El código de seguimiento que utiliza son cuadrados de color negro.
La capacidad de utilizar cualquier patrón cuadrado.
Fácil calibración del código de la cámara.
Lo suficientemente rápido como aplicaciones en tiempo real.
SGI IRIX, Linux, MacOS y distribuciones del sistema operativo Windows
son compatibles.
Capítulo 2. Proyecto TApir
32
Se distribuye con código fuente completo.
ARToolKit será la piedra angular para el desarrollo del proyecto, ya que por su
flexibilidad y fácil acceso es posible utilizarla, además su código fuente es abierto
dejando la senda abierta para masificar el uso de aplicaciones de RA.
2.2.1. Detección de marcadores mediante ARToolKit
Figura 17. Estructura del reconocimiento de marcadores.
Abstracción de la Figura 17:
Captura de video desde cámara
En el momento de la activación de la cámara el sistema ya fue
cargado con variables de entorno, ya que así es como ARToolKit lo
establece en sus algoritmos; independientemente del algoritmo a
tratar, la cámara busca en el entorno un arreglo de cuatro puntos
Capítulo 2. Proyecto TApir
33
característicos pertenecientes a los marcadores de RA, los cuales
son cuadros con borde color negro exterior y un cuadrado interior de
color blanco con un símbolo, por ahora solo se abordara en esa
descripción sobre los marcadores, mas adelante en la lectura se
indagara en la metodología de estos.
Secuencia de vídeo desde la cámara.
Para la búsqueda del marcador ARToolKit primero busca el arreglo y
para ello utiliza un filtro de video sobre la imagen saturando el
ambiente creando un efecto similar a una escala de grises y se
convierten los fotogramas a binario para verificar la existencia de un
conjunto de puntos correspondientes a un arreglo cuadrado, en este
punto solo se comprueba si hay algún marcador en el campo de
visión de la cámara y es entonces cuando solo se verifica el borde
exterior del marcador.
Marcadores.
Si existe un arreglo de puntos pertenecientes al borde exterior,
entonces se calcula la posición de dicho marcador y se le aplican las
trasformaciones geométricas de escala, rotación y movimiento
tomando como referencia el arreglo que se analizo para detectar el
borde, después se compara el símbolo central con la base de
conocimiento del algoritmo.
.
Posiciones y orientaciones de las marcas.
Capítulo 2. Proyecto TApir
34
Cuando el símbolo coincide con la base del conocimiento, los valores
del arreglo a los cuales ya se les había dado tratamiento son
aplicados sobre el modelo 3D para alinearlo con el marcador.
Objetos virtuales.
Una vez que los objetos virtuales están en armonía con el marcador,
el sistema de renderizado lo sobrepone en el arreglo, el cual es el
conjunto de puntos del borde exterior.
Secuencia de vídeo para el usuario.
Cuando el objeto se encuentra alineado y esta sobrepuesto en el
marcador, se integra sobre el video y lo muestra al usuario, después
el sistema continúa analizando el comportamiento del marcador, para
así, aplicarle el tratamiento necesario en caso de moverlo.
2.3. Librerías y software
Las herramientas ARToolKit pueden compilarse en casi todas las distribuciones de
sistemas operativos existentes, es por eso que para el desarrollo del proyecto
TApir, una de las oportunidades fue usar un sistema operativo de código abierto,
además el sistema operativo abierto concede una manipulación completa en la
administración del entorno del sistema a diferencia de otros sistemas operativos
en donde la modificación del sistema es muy complicada o inaccesible, además en
estos sistemas es necesario instalar software privativo y existen diversas opciones
o versiones para compilar programas, algo útil pero tedioso, ya que, puede ser
difícil compilar las herramientas debido a la variedad de librerías y dependencia de
las ARToolKit y es fácil perderse si no se define de manera correcta el path de
referencias en sistemas como Windows o MacOS, en el sistema abierto el instalar
Capítulo 2. Proyecto TApir
35
software es muy fácil y es muy fácil definir path para las dependencias o
cabeceras de los algoritmos de RA.
2.3.1. OpenCV
OpenCV (por sus siglas en ingles “Open Source Computer Vision”) es una
biblioteca de funciones de programación para la visión por computadora en tiempo
real.
OpenCV es liberado bajo una licencia BSD, es gratuito tanto para uso académico
como comercial. Fue originalmente escrito en C, pero consta de una completa
interfaz en C++ y todos los nuevos desarrollos se encuentran en este último
lenguaje. También cuenta con una interfaz en Python. La biblioteca cuenta con
más de 2000 algoritmos optimizados. Se utiliza en todo el mundo y sus
aplicaciones van desde el arte interactivo, a la inspección de minas, construir
mapas en la web a través de la robótica avanzada, entre muchas otras
aplicaciones y áreas.
OpenCV resuelve un gran número de problemas relacionados con la
entrada/salida e interfaz de usuario las cuales son:
Funciones de creación de imágenes
Funciones de lectura/escritura de ficheros de imágenes
Operaciones de creación y uso de ventanas
Acceso a los píxeles de las imágenes
Ofrece funciones para entrada de vídeo (desde cámara y desde archivos
AVI, MPG, WMV y MOV, según los codecs instalados en el sistema) y
salida de vídeo (en formato AVI).
OpenCV es de gran ayuda para el proyecto, puesto que es necesario sus librerías
Capítulo 2. Proyecto TApir
36
para que ciertos algoritmos de la ARToolKit logren interactuar de forma fluida
sobre video en directo.
2.3.2. GLUT
GLUT (del inglés “OpenGL Utility Toolkit”) es una librería de utilidades para
programas OpenGL que principalmente proporciona diversas funciones de
entrada/salida con el sistema operativo. Entre las funciones que ofrece se incluyen
declaración, manejo de ventanas, interacción por medio de teclado y ratón.
También posee rutinas para el dibujado de diversas primitivas geométricas (tanto
sólidas como en modo wireframe) que incluyen cubos, esferas y teteras. También
tiene soporte para creación de menús emergentes.
La librería que se usará para el proyecto TApir es freeglut la cual permite al
usuario crear y gestionar las ventanas que contienen contextos OpenGL.
2.3.3. OpenVRML
OpenVRML es de ejecución libre y multiplataforma para el soporte de VRML y
X3D esta disponible bajo la licencia GNU. La distribución OpenVRML incluye
librerías que pueden usarse para agregar soporte a VRML/X3D. En las
plataformas donde GTK+ (entorno de escritorio GNOME) está disponible,
OpenVRML ofrece un plug-in para representar mundos VRML/X3D en los
navegadores Web.
A pesar de la presencia de GLUT en el proyecto se integran modelos en formato
.wrl, es por esta motivo el cual se incluye VRML, además de que al desarrollador
del proyecto TApir le pareció un lenguaje agradable, puesto que tiene mas
conocimiento sobre este a diferencia de GLUT; hay que resaltar que GLUT ofrece
mejor soporte en cuanto a gráficos pero al final VRML por su sencillez y
familiaridad con el software fue elegido.
Capítulo 2. Proyecto TApir
37
2.3.4. Python
En el proyecto TApir se desea incluir una pequeña interfaz de usuario para facilitar
la invocación de las aplicaciones, ya que el uso de ARToolKit y dependencias solo
hacen posible la compilación y creación de aplicaciones en RA, es por ello que se
integrarán más programas para el desarrollo de la pequeña interfaz.
Python es un lenguaje de programación de alto nivel cuya filosofía hace hincapié
en una sintaxis muy limpia y que favorezca un código legible, permite trabajar con
mayor rapidez e integrar sistemas con mayor eficacia, en la Figura 18 se es
posible ver el logotipo.
Se trata de un lenguaje de programación multiparadigma (permite implementar
programación estructurada y/u orientada a objetos en el mismo código fuente) ya
que soporta orientación a objetos, programación imperativa y, en menor medida,
programación funcional. Es un lenguaje interpretado, usa tipificación dinámica, es
fuertemente tipificado y multiplataforma. Posee una licencia de código abierto,
denominada “Python Software Foundation License” que es compatible con la
Licencia pública general de
GNU.
Se ocupa Python en este
proyecto porque es capaz de
integrar sentencias desde un
shell, ya que para la invocación de los algoritmos RA se hace por medio de una
terminal o shell, Python será el encargado de llamar y compilar en shell con un
click.
Figura 18 Logo Python.
Capítulo 2. Proyecto TApir
38
2.3.5. Glade
Para la parte del lienzo en donde se dibujarán los botones y se conectaran las
señales de Python se utilizara el software Glade ya que éste utiliza una integración
con Python, es muy fácil de programar y además de crear su estructura en un
archivo xml.
Glade es una herramienta RAD (en ingles “Rapid Application Development”) para
permitir el desarrollo rápido y fácil de interfaces de usuario para GTK+ toolkit y el
entorno de escritorio GNOME.
Las interfaces de usuario diseñada en Glade se guardan como xml, y usando los
escritorios GTK+ y GtkBuilder estos pueden ser cargados por las aplicaciones de
forma dinámica según sea necesario.
Mediante el uso de los entornos GtkBuilder y archivos xml de Glade es posible
utilizar varios lenguajes de programación como C, C++, Java, Perl, Python entre
otros.
Glade es un software libre publicado bajo la Licencia GPL (General Public
Licence) además su interfaz es muy intuitiva para desarrollar entornos de
escritorio, en la Figura 19 se puede ver las ventanas del software.
Capítulo 2. Proyecto TApir
39
Figura 19. Interfaz de Glade.
2.3.6. VRML
VRML (sigla del inglés “Virtual Reality Modeling Language”. "Lenguaje para
Modelado de Realidad Virtual") es un formato de archivo normalizado que tiene
como objetivo la representación de escenas u objetos interactivos
tridimensionales; diseñado particularmente para su empleo en la web.
El lenguaje VRML posibilita la descripción de una escena compuesta por objetos
3D a partir de prototipos basados en formas geométricas básicas o de estructuras
en las que se especifican los vértices y las aristas de cada polígono tridimensional
y el color de su superficie. VRML
permite también definir objetos 3D
multimedia, a los cuales se puede
asociar un enlace de manera que el
usuario pueda acceder a una página
web, imágenes, vídeos o archivos
VRML de Internet por medio de un Figura 20. Logo VRML.
Capítulo 2. Proyecto TApir
40
plug-in en el navegador web. En la Figura 20 esta el logo de VRML.
La función de VRML en el proyecto TApir es definir los modelos 3D que se usaran
para integrar en la realidad, esto fue por la estructura y portabilidad que ofrece el
software.
2.2. Marcadores RA
La idea básica de la Realidad Aumentada es la de superponer gráficos, audio y
otro tipo de archivos o información a un ambiente real en tiempo real. Podría sonar
bastante simple, pero no lo es. Aunque hace décadas que las cadenas de
televisión vienen haciendo esto, lo hacen con una imagen estática que no se
ajusta al movimiento de las cámaras.
La Realidad Aumentada es muy superior a lo que se viene utilizando en televisión,
si bien, ediciones iníciales de Realidad Aumentada se muestran actualmente en
eventos deportivos televisados, para mostrar información importante en pantalla,
como los nombres de los pilotos de carreras, repeticiones de jugadas polémicas o
principalmente, para desplegar publicidad. Estos sistemas despliegan gráficos solo
desde un punto de vista. La próxima generación de sistemas de realidad
aumentada desplegará gráficos para la perspectiva de cada espectador.
El punto principal dentro del desarrollo de la RA es un sistema de seguimiento de
movimiento o “Tracking System”. Desde el principio hasta ahora la RA se apoya en
“Marcadores” o un arreglo de marcos como se muestra en la Figura 21, es una
parte importante dentro del campo de visión de las cámaras, ya que es en donde
la computadora toma el punto de referencia sobre el cual superponer los datos.
Estos marcadores son predefinidos por el usuario y pueden ser pictogramas
exclusivos para cada imagen a ser superpuestas, o formas simples, como marcas
de cuadros, o simplemente texturas dentro del campo de visión. Recientemente en
Capítulo 2. Proyecto TApir
41
A
A A
V
los últimos años el desarrollo de RA “markerless” esta madurando, añadiendo un
grado más a la inmersión al no tener que trabajar con tarjetas o cosas extrañas el
ambiente.
Los marcos tienen establecido un tamaño para mejorar el desempeño al
reconocerlo, aunque cambiarlo no afecta en gran medida, ya que, el programa
interpretaría que esta alejado o muy cerca de la cámara y en consecuencia
tomaría la referencia del tamaño incrustando de manera equivalente en el marco
los datos, ese sería el único inconveniente.
La estructura del marcador es muy simple, pero contiene una pictografía única,
creando así perspectivas diferentes para lograr las trasformaciones geométricas.
El diseño consta de un cuadro de 8cm con
otro cuadro interior de 4cm de color blanco y
un símbolo, creando en el exterior del
marcador un margen el cual es de color
negro; la funcionalidad del símbolo es
referenciar el punto pivote en el cual se
aplicaran las transformaciones y para lograr
este cometido el símbolo debe de presentar
una deformación si este es rotado, esto para
preservar el punto pivote.
Por ejemplo:
Existe un marcador con las especificaciones previas, pero toma como símbolo la
letra “A”; la forma “A” tomaría el pivote, ahora si “A” es rotada en sentido a las
manecillas del reloj en 90º su forma es “ ” de esta forma se crean símbolos
diferentes, de modo que los símbolos que se obtendrían, en 4 estados de rotación
en sentido a las manecillas del reloj hasta completar la hora son: “A”, “ “,” ” y “ “.
Si el símbolo fuera la letra “O” el sistema detectaría todos los ángulos como pivote
y en consecuencia no habría rotación.
Figura 21. Marcadores para el uso de RA.
Capítulo 3. Integración del Proyecto TApir
Capítulo 3.
Integración del
Proyecto TApir
Capítulo 3. Integración del Proyecto TApir
45
3.1. Identificación de factores
Para concretar el proyecto TApir se tomó como punto inicial el comprender el
funcionamiento de RA implicando a las ARToolKit de por medio, de tal manera la
investigación fue centrada en programas que utilizaban las librerías, para
posteriormente obtener conceptos destacados de tales software, así mismo se
llevo a cabo la búsqueda de documentos e información acerca de la tecnología de
RA, dando como resultado un soporte solido en donde la factibilidad del proyecto
era en forma consistente.
La factibilidad del proyecto es gran parte a la ARToolKit, pues su código por ser
distribuido de forma abierta y su disponibilidad para compilarlo en casi cualquier
sistema operativo, otorgo una brecha en la cual el proyecto lograba fluir de manera
estable sobre el entorno de desarrollo.
La decisión del desarrollo en una plataforma Linux, fue la posibilidad y gran
variedad de software con código abierto, incluyendo que la mayoría de programas
en RA actuales son principalmente para plataformas Windows y MacOS, surgió la
iniciativa de contribuir con los opensource, creando un sistema de RA para el
entorno Linux. El sistema operativo concede la libre manipulación y variedad de
librerías, aunque genéricas, son de utilidad pues demuestran ser un apoyo en el
momento de compilar, por su facilidad al ser instaladas.
El software evaluado fue AMIRE y ATOMIC, con la familiaridad de renderizar sobre
video en directo un modelo tridimensional, además de utilizar ARToolKit, cada
software las compila de forma diferente.
La idea de la aplicación de RA es que el usuario final logre interactuar con el
sistema de manera fácil utilizando un sistema de código abierto como Linux, pero,
dado a que se utilizan demasiados parámetros para lanzar la aplicación surgió la
necesidad de utilizar un programa integrador para crear una aplicación de
Capítulo 3. Integración del Proyecto TApir
46
desarrollo rápido como Glade y Python para crear una pequeña interfaz de usuario
con ejemplos de la ARToolKit y un programa propio.
3.2. Interfaz de TApir
Para que los programas en Realidad Aumentada se logren ejecutar, es necesario
usar comandos e interpretes, algo que es muy complicado, para que el usuario
logre interactuar con las aplicaciones, por este motivo surge la necesidad de
ejecutar el programa por medio de una interfaz que permita la interacción entre el
usuario y los programas de Realidad Aumentada.
Glade ofrece una interfaz muy intuitiva para la creación de ventanas, en este caso,
se diseño una pequeña interfaz que ayude al usuario a comunicarse con la
aplicación de Realidad Aumentada, ya que para la ejecución de los programas se
debe hacer uso de interpretes de comandos desde una terminal, la idea de la
interfaz es facilitar el uso de la tecnología en Realidad Aumentada para que el
usuario final sólo disponga de una ventana de interacción para disponer de
software.
Glade sólo permite dibujar la interfaz, lo que indica que al tener la interfaz
terminada esta no realiza alguna acción o evento al pulsar algún botón; es aquí
donde interviene Python, en el cual mediante un archivo crea los eventos sobre la
interfaz creada en Glade, esto con el motivo de que Python tiene acceso a nivel de
terminal y puede interpretar scripts; en la Figura 22 es mostrado un diagrama de
bloques que facilita la interacción entre los software.
Capítulo 3. Integración del Proyecto TApir
47
Figura 22. Diagrama de bloques: Relación TApir, Python y Glade.
Para abarcar ampliamente la estructura de TApir y la relación con la Figura 22, a
continuación se desglosa su integración con el software:
Para que TApir se comunique con los algoritmos, primeramente fue necesario
compilarlos y crear un script que cargara las variables, para esto el script se
interpreta en bajo nivel en una terminal.
La función de Glade es la de proporcionar una interfaz, en donde, de forma simple,
sea posible ejecutar algoritmos de RA; para que este proceso se posible existe
una comunicación entre Python y Glade mejor conocida como conectar señales
[14], para que Python se sincronice con la interfaz de Glade hace falta definir
sobre Python que archivo de Glade se desee cargar y para ello la sintaxis
siguiente realiza ese proceso:
Capítulo 3. Integración del Proyecto TApir
48
localpath = path.expanduser("~/.TApir0.4beta/bin/interfaceT.Glade")
self.widgets = gtk.Builder()
self.widgets.add_from_file(localpath)
Las conexiones entre Python y Glade es mediante eventos sobre la interfaz de
Glade, la definición del evento que usa la interfaz de TApir es mediante el click del
mouse el código para conectar señales es el siguiente:
def on_button1_clicked(self, widget):
"Convert button"
popen("sh /home/$(whoami)/.TApir0.4beta/script/12.sh")
En el momento que se hace click sobre algún botón de la interfaz de Glade, el
evento click ejecuta bajo shell un script sh que contiene las variables de entorno
del programa y es así como despliega el algoritmo RA.
3.3. Compilación de programas
La compilación de las herramientas ARToolKit se elaboro bajo línea de comandos
con el compilador GCC, la estructura de datos de la ARToolKit fue modificada para
crear un algoritmo diferente al de las ARToolKit para proyecto TApir, pero el uso de
algoritmos de ARToolKit esta presente en el proyecto.
ARToolKit cuenta con archivos makefile para compilar los algoritmos, los makefile
guardan los comandos de compilación con todos los parámetros para encontrar
librerías, archivos de cabecera y demás archivos que el lenguaje C y C++ puedan
generar. Con el uso del makefile ya no es necesario escribir largas líneas de
compilación con sus respectivas opciones o, al menos, solo se ejecuta este
archivo y ahorra tiempo al momento de compilar programas robustos.
Capítulo 3. Integración del Proyecto TApir
49
El proyecto TApir comenzó la compilación de algoritmos de ARToolKit, pues esto
sería el corazón del proyecto, aunque surgieron inconvenientes en la compilación
la inclusión del los makefile en el sistema operativo facilito la manipulación de las
herramientas RA. Fue es necesario construir en una terminal el método de
compilación para la ARToolKit; para construir los makefile en línea de comando, se
debe ubicar la dirección absoluta del archivo y escribir el comando make el cual
busca y construye archivos makefile, una vez realizada esta acción en la terminal
se desplegaran códigos de compilación, los cuales generan archivos compilados
de la ARToolKit, para que después sean ejecutados para desplegar las
aplicaciones de RA.
3.4. Ejecución de programas
El programa simpletest.c referente a los ejemplos de la ARToolKit, fue el primer
algoritmo en ser compilado con herramientas make bajo una terminal, es por ello
que se modifico archivo makefile para que logrará satisfacer de forma eficaz la
creación del programa para la correcta compilación. Para compilar el programa
simpletest.c se necesita acceder a la carpeta en donde esta contenido y
posteriormente ejecutar el comando make como lo muestra la Figura 23, en la cual
se observa en la primera línea de la terminal la ubicación absoluta de la carpeta
que es /Escritorio/TApir/RA-algoritmos/simple; posteriormente es posible observar
el contenido de la carpeta en un color verde, esto con el motivo de ver los archivos
y de todo ellos el mas importante es el de llamado simpleTest.c; sobre la misma
imagen se puede ver que se ejecuta el archivo makefile con el comando make y
se puede observar la compilación del programa el cual se ha ejecutado de manera
correcta.
Capítulo 3. Integración del Proyecto TApir
50
Figura 23. Ejecución en terminal del comando make.
La compilación del programa simpletest.c se generó de manera correcta, ahora es
momento para ejecutarlo, hay que entender que el programa sólo se compiló, es
decir, se construyó el contenido más no se envió a ejecutarse. Ahora se deben de
inicializar variables de entorno para que el programa se logre ejecutar, estas
variables son las que determinan el uso de la cámara web, el tamaño del video,
cuadros por segundo, llamadas a las librerías ARToolKit, entre otras funciones.
Como las variables de entorno son demasiadas se construyo un archivo sh el cual
es parecido al makefile, sólo que el sh se crean las variables que el programa
necesita para su ejecución. El archivo sh de la Figura 24, muestra el tipo de
cámara que se va a usar y en que puerto, define el radio de la imagen en una
escala de 640x480. También se le es asignada una relación de 30 cuadros por
segundo, ajuste de color usando la escala RGB y por último llama el programa
compilado en consola para ejecutarlo con las variables descritas anteriormente.
Capítulo 3. Integración del Proyecto TApir
51
Figura 24. Archivo sh.
Para la ejecución del programa simpletest.c, se contempla que el archivo sh debe
de estar al mismo nivel de datos que el archivo compilado, o de otra forma hacer
una modificación en el sh sobre la ultima línea en donde se defina la dirección
absoluta del archivo compilado por ejemplo el archivo compilado se encuentra en:
/home/usuario/Escritorio/TApir/algoritmos_compilados/simpletest
Posteriormente el sh se localiza en:
/home/usuario/Escritorio/TApir/scripts/simpletest.sh
Se maneja el mismo nombre en los archivos para facilitar la búsqueda,
modificación y dependencia entre unos y otros, la diferencia está en el tipo de
extensión del archivo.
El archivo sh el cual es un script necesita ser invocado desde una terminal, pues
contiene llamadas al sistema de bajo nivel, para que el programa RA sea
desplegado, es necesario ejecutar el script sh, en si la llamada al script es larga,
pero a diferencia de escribir las variables de entorno en terminal y después
dirigirlas al programa RA son mas extensas que invocar el script. La ejecución del
Capítulo 3. Integración del Proyecto TApir
52
archivo sh es la siguiente: sobre la línea de comandos de la terminal se accede a
la carpeta en donde esta el sh, en este caso se encuentra al mismo nivel que el
archivo compilado, entonces se escribió en terminal lo siguiente:
sh /home/usuario/Escritorio/TApir/algoritmos_compilados/simple.sh
Una vez que se halla escrito en terminal la sintaxis anterior, el archivo sh comienza
la generación del programa simpletest.c, el cual de acuerdo a la lógica del
algoritmo realiza el renderizado de una esfera cuando a la cámara web se la
superpone un patrón cuadrado con características marcadas. Ver Figura 25.
El código del programa simpletest.c consiste en llamar un archivo xml el cual inicia
la cámara, a diferencia del archivo sh que su función es enviar parámetros
después de iniciar la cámara, posteriormente se crean las variables que
controlarán el umbral para crear un efecto parecido al de la Figura 26.
.
Figura 25. Ejecución del programa simpletest.c.
Figura 26. Efecto de umbral para identificar marcadores.
Capítulo 3. Integración del Proyecto TApir
53
Sobre el programa simpletest.c se carga un archivo binario que contiene la
codificación del patrón a reconocer, el cual lleva por nombre patt.hiro, una vez que
se ha comprobado lo anterior el archivo sh envía los parámetros a la cámara y
comienza la detección de cuadros del video en tiempo real, una vez que se
detectan los 4 fudicial points se crean marcos de referencia entre cada punto para
formar un arreglo, al detectar este comportamiento a través del umbral se localiza
el marcador y se le otorgan posiciones sobre el ambiente real (ver Figura 27).
Después de la detección de las formas cuadradas se analiza la figura o marca
central, se realiza una conversión a binario para comprobarla con el archivo de la
base del conocimiento, si no hay distorsión dentro del marcador se envía a dibujar
en pantalla, una forma geométrica simple.
Figura 27. Posición del marcador.
Capítulo 3. Integración del Proyecto TApir
54
3.5. Integración de modelos tridimensionales
complejos
Para que se lograrán incrustar elementos virtuales más complejos se utilizó el
programa simpleVRML.c el cual logra integrar modelos tridimensionales en
formato VRML sobre video en directo; la funcionalidad del programa
simpleVRML.c es similar a la del programa simpletest.c en cuanto a la
inicialización de cámara y reconocimiento del marcador.
Se modifico el programa simpleVRML.c para que lograra el reconocimiento de 4
marcadores, con la finalidad de que en cada marcador mostrara un modelo
diferente, creando así un programa que lograra integrar sobre video en directo 4
modelos en tiempo real de manera conjunta, ya que el programa simpleVRML.c
solo puede renderizar un modelo.
Para que se lograra cargar los 4 modelos en el programa simpleVRML se edito el
archivo object_data_vrml sobre el cual están creadas las referencias de los
marcadores y a qué modelo en 3D apuntan.
La estructura de referencias hacia los modelos y marcadores, es la forma en que
van referenciados los actores de la detección de marcadores, es decir toma
aspectos importantes para crear la mezcla de realidades.
La primera línea del código de marcadores es solo como comentario para referirse
al marcador 1:
#pattern 1
VRML Wrl/bee.dat
Pero la segunda línea define una ruta hacia un archivo .dat, el contenido del
archivo mostrado a continuación:
Capítulo 3. Integración del Proyecto TApir
55
bee.wrl
0.0 0.0 50.0 # Translation
90.0 1.0 0.0 0.0 # Rotation
25 25 25 # Scale
El código anterior, no es más que la definición de transformaciones geométricas
iníciales, son necesarias para ser sobrepuestas sobre el marcador y después ser
manipuladas por el algoritmo. Es importante nombrar al archivo .dat igual que el
modelo al cual que se le envían los parámetros, ya que, como las ARToolKit no
pueden interactuar directamente con archivos .wrl, el único medio es por el archivo
.dat.
Para continuar con la estructura inicial al código de referencia de los marcadores,
el siguiente código es el complemento del primer código situado después de la
definición del archivo .dat:
Data/patt.hiro
80.0
La sintaxis Data/patt.hiro, crea un enlace hacia otro archivo, el cual contiene
codificación binaria y es el responsable de la verificación hacia los fotogramas que
se obtienen de la captura de video. El valor 80.0 son las dimensiones del
marcador haciendo alusión a 80mm, es decir los 8cm de acuerdo al tamaño del
marcador físico, como se comento en el capítulo 2 en el apartado “Marcadores
RA”, es posible variar el tamaño del marcador, con el inconveniente de alterar
algunas transformaciones.
Los modelos utilizados en el proyecto TApir fueron obtenidos desde la página web
http://home.comcast.net/~sharov/3d/virtual.html, la cual proporciona como material
de descarga modelos VRML elaborados por Alexei Sharov. Los modelos
descargados no sufrieron ninguna modificación en su código VRML, la única
referencia de los modelos es que fueron elaborados en 3D Studio Max para
Capítulo 3. Integración del Proyecto TApir
56
posteriormente exportarlos al formato wrl, Alexei Sharov los utiliza como
representaciones 3D en su pagina web para el departamento de Entomología del
Tecnológico de Virginia (“Virginia Tech, Blacksburg, VA”).
Ahora ya se cuenta con 2 archivos externos al programa simpleVRML.c los cuales
son object_data_vrml y un archivo .dat los cuales, su función es emparentar los
marcadores con los modelos, el funcionamiento es simple, comienza con definir el
número de marcadores (en este caso son 4), en consecuencia compara el
marcador desde la carpeta /Data con la base del conocimiento, después recibe los
parámetros de la posición del arreglo de los fudicial points y los evalúa sobre
archivo .dat que contiene los valores iníciales de los modelos .wrl, si el marcador
es consistente a la base del conocimiento superpone las imágenes sobre el video
en directo.
De la misma forma en que se compiló simpletest.c se le aplico el mismo
tratamiento a simpleVRML con las modificaciones que ya han sido comentadas. El
resultado es la correcta integración de modelos complejos sobre video en directo,
ver Figura 28.
Figura 28. Integración de modelos complejos sobre video en directo.
Capítulo 3. Integración del Proyecto TApir
57
3.6. Árbol de dependencias
La primera complicación del proyecto TApir fue la instalación de las dependencias
de la ARToolKit ya que estas crean arboles de estructura de datos, los cuales
deben de satisfacerse, para lograr instalar las dependencias deseadas. A
continuación se presentan las librerías referentes al proyecto, las cuales son de
gran importancia para el proyecto inicial; las librerías son: OpenCV, GLUT,
GSTREAMER y OpenVRML.
El problema radica en que si alguna dependencia no está instalada correctamente
los programas no se lograran compilar, es muy importante verificar la estructura de
dependencias. Para distribuciones Ubuntu y Fedora con la ayuda de la
herramienta Synaptic es posible instalar las librerías de manera sencilla; si se trata
de la distribución Debian, es todo un reto, ya que en este sistema se debe de
cargar las dependencias al kernel.
Las librerías OpenCV y GSTREAMER no causaron problemas al momento de su
instalación pero GLUT y OpenVRML pueden crear inmensos arboles de
dependencias haciendo que el desarrollar pierda gran parte del tiempo en lograr la
correcta instalación de las librerías, hay que destacar que la instalación también
depende de la arquitectura y versión del sistema operativo, ya que, puede que no
exista soporte alguno o errores de estructura de datos como en el caso de
OpenVRML, el cual ocupa libmozjs-dev y esta a su vez tiene conflictos con el
explorador firefox, la librería es necesaria para el renderizado en exploradores
web, pero el paquete desinstala por defecto firefox, este es el principal problema
con OpenVRML; el problema se resuelve en distribuciones Ubuntu y Debian
usando una variante de VRML el cual es un paquete desarrollado por Michel
Briand llamado freevrml que permite el renderizado de modelos .wrl.
Capítulo 3. Integración del Proyecto TApir
58
3.7. Comandos y archivos
Haciendo referencia al este capítulo en el apartado “Compilación de programas”,
se describen archivos para la compilación y generación de variables de entorno,
los cuales son de gran ayuda al momento de compilar en GCC, para lograr el
funcionamiento de estos archivos, primero se compilo en terminal el archivo
simpletest.c y en la esperar el despliegue de interpretes, para saber que ocurría,
en la Figura 29 se aprecian los errores de compilación sin el uso de un makefile.
La compilación en GCC no dispone de una interfaz como Java o code:blocks; en
el ambiente GCC se compila en terminal escribiendo el comando, seguido de las
opciones que el programa requiera ya sean librerías o definir variables.
Figura 29. Referencias indefinidas: simpletest.c.
La estructura del archivo makefile se puede apreciar en la Figura 30.
Figura 30. Gedit es el editor para crear un makefile.
Capítulo 3. Integración del Proyecto TApir
59
Con la inclusión del script fue posible la compilación de los algoritmos de RA
pertenecientes a la ARToolKit. El funcionamiento del makefile correspondiente al
programa simpletest.c, la importancia del archivo radica en que con el los
problemas para referenciar librerías se acaban y por su simplicidad es posible
ejecutarlo tantas veces se requiera, a continuación se desglosan segmentos
importantes del código, para comprender su importancia y beneficios:
El siguiente segmento hace referencia a las librerías básicas de GCC.
INC_DIR= ../../include
LIB_DIR= ../../lib
BIN_DIR= ../../algoritmos_compilados
El siguiente código se debía de escribir en terminal para cargar las librerías
OpenCV, GLUT y ARToolKit:
LDFLAG=-pthread -lgstreamer-0.10 -lgobject-2.0 -lgmodule-2.0 -lgthread-
2.0 -lrt -lxml2 ----lglib-2.0 -L/usr/X11R6/lib -L/usr/local/lib -L$
(LIB_DIR)
LIBS= -lARgsub -lARvideo -lAR -lpthread -lm -lglut -lGLU -lGL -lXi -lX11
CFLAG= -O -pthread -I/usr/include/gstreamer-0.10 -I/usr/include/glib-2.0
-I/usr/lib/glib-2.0/include -I/usr/include/libxml2 -I/usr/X11R6/include -I$
Los archivos makefile son de gran ayuda para programas que requieren de
librerías múltiples, en este caso son perfectos para el compilador GCC, cualquier
otro lenguaje de programación sería un poco tedioso, ya que por ejemplo
code:blocks o borland, es necesario definir las librerías para que el compilador y
crear el path para que se ejecute el programa; pero el desarrollo del proyecto
TApir definió el uso de GCC para la creación de aplicaciones en RA, GCC es el
lenguaje ideal para lograr comprender el árbol de librerías y evaluar los algoritmos,
añadiendo que el sistema operativo y herramientas seleccionadas para el
desarrollo se definieron como la mejor opción por el desarrollador.
Capítulo 3. Integración del Proyecto TApir
60
El comando para ejecutar el archivo compilado corresponde a la sintaxis
./nombre_del_programa esta opción se usa para lanzar cualquier archivo
ejecutable en sistemas Linux, pero una vez que se escribe esa instrucción
llamando a un programa de realidad aumentada no realiza acción alguna, el
motivo de esto se debe a que son necesarias variables de entorno para que el
programa se ejecute. Las variables de compilación se escriben antes de escribir
./nombre_del_programa y se deben de realizar cada vez que se requiera lanzar un
programa.
Ejecutar líneas de comandos para lanzar las aplicaciones del proyecto no es un
caso práctico para el usuario final, es por ello que se crearon archivos sh los
cuales pueden lanzar con escribir una sentencia de comando.
En la Figura 31 es posible ver una ventana con el código del sh correspondiente al
programa simpletest.c, en el cual son cargadas las variables de entorno
necesarias para que el programa se ejecute.
Figura 31. Gedit mostrando un sh.
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
Capítulo 4.
Evaluación,
Pruebas y Análisis
de Resultados.
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
63
4.1. Pruebas TApir
TApir fue creado en un equipo de altas prestaciones, pues el equipo contaba con
una memoria RAM de 6GB, procesador AMD Phenom II X6 de 6 núcleos y una
tarjeta grafica Nvidia GeForce 8300. Aun contando con las características de
hardware mencionadas la ejecución del programa con 4 modelos 3D tardaba
demasiado en crear el ambiente de RA, pero creaba de forma eficiente la
integración de los modelos tridimensionales sobre el video en directo.
Al intentar ejecutar el proyecto TApir en un equipo diferente, surgió la necesidad
de instalar las dependencias para el correcto funcionamiento de la aplicación, fue
ahí donde se observo que TApir necesitaba soporte por parte del desarrollador
para la correcta instalación del proyecto, ya que el usuario final desconoce que
tipo de librerías se requieren, además del desconocimiento del proceso de
instalación de las mismas.
Debido al inconveniente de la gran variedad de librerías, el proyecto opto por
reducir su estructura en cuanto a dependencias, puesto que el objetivo del
proyecto es mostrar aplicaciones de RA, las dependencias fueron reducidas para
solo instalar las que contribuían a TApir, con solo las librerías de ejecución fue
posible crear el proyecto más portable, ya que, solo son necesarios los paquetes
libopenvrml4_0.14.3-3_i386.deb, libstdc++5_13a3.3.6-17ubuntu1_i386.deb y
freeglut.
El paquete libopenvrml es referente a OpenVRML, es el motor para el renderizado
de modelos VRML; el paquete libstdc++ ofrece soporte de ejecución al programa
compilado, ya que son el librerías C++, entre las que destacan las de uso grafico
como until por ejemplo, y por último freeglut permite al usuario crear y gestionar
ventanas usando contextos OpenGL, además concede las funciones del ratón,
teclado y joystick.
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
64
La principal diferencia entre los paquetes y las dependencias, es que con el uso
de los paquetes deb no es posible compilar programas de RA, pero dado a que
TApir es para un usuario final, fueron compilados los archivos en un equipo con
todas las dependencias para posteriormente integrarlos al proyecto y crear un
contenedor tar.gz, el cual contiene el código necesario para crear una portabilidad
en el programa y lograr desplegar algoritmos RA.
Las primeras pruebas de TApir constaron de verificar el reconocimiento de un
marcador en escena e ir aumentado el número de estos para que posteriormente
se presenten ante la cámara 4 marcadores con sus respectivos modelos 3D. La
incrustación, translación, rotación y escalamiento de los 4 modelos sobre video en
directo se efectuaba de manera correcta, pero el ambiente influía en el proceso de
detección de marcos, ya que, dependiendo de la luces del entorno en donde se
ejecute el programa, reconocer la
forma del marco se vuelve más difícil
de diagnosticar, esto se debe a que el
método para reconocer marcadores
usa un efecto llamado umbral, el cual
consta en aplicar un filtro al video de
captura perteneciente a la cámara
web, y dado a la intensidad de la luz,
puede crear distorsión en el marcador
afectando el reconocimiento de
marcas. En la Figura 32 se puede
observar el método de reconocimiento
del marcador usando el umbral.
Cuando el proyecto obtuvo su portabilidad y lógica en la estructura de los
algoritmo, las pruebas en equipos con características diferentes en cuanto a
hardware definirían los requerimientos del proyecto, es por ello que TApir se
ejecuto en el equipo en el que fue desarrollado, el cual mostraba gran desempeño
en cuando a hardware, y se comenzó a evaluar el tiempo de respuesta del
Figura 32. Reconocimiento de marcador usando el filtro umbral.
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
65
programa, el cual fue de aproximadamente 20 minutos, tras ese lapso de tiempo
se desbordo la memoria del equipo creando un deadlock, al parecer el renderizado
de 4 modelos 3D es demasiado esfuerzo para el equipo y contando que la
estructura de las ARToolKit fue modificada para la creación del proyecto, se
especulaba que las estructuras externas como en el uso de sh afecta el
desempeño de la aplicación; pero TApir consolidaba ser un buen ejemplo hacia la
tecnología de RA.
En el transcurso de las pruebas realizadas a TApir en diferentes equipos en donde
un equipo reflejaba un requerimiento en RAM de 1GB, el proyecto solo puede
ejecutar programas simples de RA como es el integrar modelos simples
generados por GLUT, y dado a que solo permitía ejecutar los programas base de
la ARToolKit el desempeño del sistema era constante y no presento ninguna
anomalía.
En la prueba de una laptop de 4GB en RAM y con un procesador i3, lograba de
manera efectiva el renderizado de los 4 modelos, integrando muy bien el ambiente
y manipulando el umbral en video en directo, un dato curioso es que al
desconectar el equipo la aplicación comienza a fallar de manera casi inmediata
provocando inestabilidad en el sistema operativo y recurriendo a forzar la
terminación del proyecto o aplicar métodos mas agresivos.
Después de probar el proyecto en equipos menos dotados en hardware, la interfaz
de usuario fue capaz de mostrarse sin ningún problema en cualquier equipo que
cuente con un sistema Ubuntu, además, la interfaz se desplegaba
independientemente de la versión del sistema e inclusive se puede lanzar una
prueba de gráficos en GLUT, claro con las dependencias necesarias; el problema
es al cargar el modelo por falta de hardware en el equipo, ya que se diagnostica
que el proyecto, en cuanto a su estructura, funciona de forma correcta.
Entre los requerimientos del proyecto existe la incompatibilidad en ciertas cámaras
web, principalmente con dispositivos que tienen controladores privativos y esto se
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
66
debe a que el fabricante no desea que su producto realice funciones a las que el
dueño no tiene alcance, limitar el uso del producto para el software propio y
disposición del sistema operativo para el cual fue elaborado, es una limitante que
afecta principalmente a los sistemas de código abierto, por ejemplo en las laptop’s
de sony y hp es posible la instalación de un sistema operativo abierto pero el
utilizar los dispositivos integrados como paneles adicionales al teclado o táctiles,
no es posible su utilización por parte del software abierto como es Ubuntu,
impidiendo explotar al máximo dichos componentes.
Aun con software privativo, el proyecto es útil si es configurada y conectada una
cámara web mediante el puerto usb, esto amplia el rango de la cámara pues es
posible integrar dispositivos digitales de hasta 10 pixeles obteniendo una mejor
calidad al momento de reconocer un marcador; la posibilidad de utilizar cámaras
externas es posible al script sh en donde el habilitar puertos usb para el dispositivo
digital es muy fácil, pero para la configuración de dicho dispositivo hace falta la
intervención del desarrollador o conocimiento del entorno a manipular, esto
representa una desventaja al proyecto, puesto que es para un usuario final, pero
es una ventaja al desarrollo por la manipulación de diferentes dispositivos
digitales.
TApir esta emparentado con software de RA como es AMIRE y ATOMIC, en
principio para que el desarrollador entendiera que es RA, fue necesario ver la
tecnología en directo, pues, aunque la RA sea descrita con lujo de detalle, las
posibilidades de entenderla mediante escritos o experiencias de terceros son
reducidas, esto debido a que la experiencia al contacto con la tecnología, es gran
medida un factor importante para comprender la metodología de la RA, las
posibilidades son extensas con tan solo ver el potencial de estas herramientas.
La importancia de utilizar software como AMIRE y ATOMIC, fue en gran medida
como material didáctico para analizar herramientas de RA, así como también
formaron parte del proyecto como motivación, incitando a la iniciativa para crear
una extensión de estas, en un principio, que después desemboco para crear un
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
67
proyecto que realizara tareas similares.
Anteriormente se han destacado software de RA que contribuyeron al desarrollo
del proyecto, pero no se ha especificado que tipo de tecnología utilizan o para que
sistemas están disponibles, en la Figura 33 es posible apreciar una comparación
de características entre TApir los otros software.
Plataforma Licencia Interfaz de usuario
Lenguaje de
programación
IDE para la
compilación
AMIRE
Disponible
para
sistemas
Windows
desde XP
LGPL Win32 (MS
Windows) C y C++
Visual Basic
y similares
ATOMIC
Linux,
Windows y
Mac
GPL Java JRE C y C++
Netbeens,
eclipce por
mencionar
los mas
populares
TApir Linux GPL GDM (GNOME
Display Manager) C y C++ GCC
Figura 33. Comparación entre software.
Para entender las diferencias entre software, a continuación se desglosan
características importantes para determinar los alcances de dichos entornos RA:
AMIRE por su licencia LGPL (GPL Library or Lesser General Public License; en
español librería de licencia publica); mantiene en disposición publica solo las
librerías del proyecto, puesto que se trata de ARToolKit, pero aun así es posible
modificar su estructura y funcionamiento. Los algoritmos de AMIRE tienen la virtud
Capítulo 4.Evaluacion, Pruebas y Análisis de Resultados
68
de asignar a un marcador el modelo que el usuario desee y guardarlo para
después ejecutarlo en cualquier momento; además de que AMIRE es soportado
por el sistema operativo mas popular: Windows, esto hace de AMIRE un software
de gran escala no solo por su entorno de Microsoft sino en la posibilidad de
manipular los marcos y modelos que son necesarios para crear RA.
Desafortunadamente el proyecto AMIRE termino en el 2004, pero aun es posible
descargar el software desde su página web.
ATOMIC es un software en el cual la posibilidad de manipular marcadores e
incrustarles cualquier modelo es muy simple; ATOMIC cuenta con una interfaz
muy sencilla en la cual se asocian los marcos con los modelos con solo indicar el
directorio de estos. Por su estructura en Java es posible ejecutar ATOMIC en todos
los sistemas operativos, claro siempre y cuando cuenten con la maquina virtual de
Java y dispongan del hardware necesario; pero por utilizar un lenguaje
interpretado en el que ATOMIC se despliega, el potencial de las herramientas RA
decrecen considerablemente.
TApir por solo ejecutarse en sistemas abiertos no permite la masificación del
proyecto, pero ese no es el objetivo de TApir, si no que, el proyecto pretende
alcanzar y proporcionar herramientas para esclarecer el panorama de la RA, de tal
manera que TApir es un software demostrativo del potencial y alcance de
tecnologías en el entorno aumentado.
Capítulo 5. Conclusión y Aplicaciones Futuras
Capítulo 5.
Conclusión y
Aplicaciones
Futuras.
Capítulo 5. Conclusión y Aplicaciones Futuras
71
5.1. Conclusiones
La metodología de la Realidad Aumentada parece ser fácil, el sobreponer objetos
en un video ya se ha visto en la televisión, pero los objetos que se integran en
televisión son viñetas o plantillas que un usuario manipula, y al tener el control
sobre sus coordenadas se logra integrar los objetos virtuales a la realidad, pero en
la Realidad Aumentada, computacionalmente son procesos muy complejos que
requieren la validación de objetos a diferencia con la televisión, además, no existe
un usuario que manipule los objetos o incruste información sobre el video en
directo, sino que, el algoritmo de RA es el que controla el flujo de datos y coloca al
objeto en las coordenadas correctas.
Hoy en día en el desarrollo de aplicaciones de RA se buscan métodos para utilizar
mejorar el reconocimiento de objetos, destaca el uso de GPS para buscar
maneras de reconocer formas en un ambiente abstracto, desde calcular las
coordenadas de los objetos como lo hace Mizell, D.W o por medio de puntos
característicos llamados fudicial points como es el caso de Kutulakos, K.N, pero
como fue comentado en el inicio de este documento, existen diversos métodos
iguales de atractivos y funcionales en los que la RA puede ser interpretada.
En la construcción de proyecto TApir fue posible conocer y manejar aplicaciones
de RA, puesto que se analizo estructura y características que la conforman, esto
gracias al análisis y compilación de ARToolKit, que es el punto de partida para la
implementación del desarrollo, el cual determino una aproximación hacia la RA;
obteniendo una aplicación que permita interactuar con algoritmos básicos de la
librería ARToolKit, para así lograr implementar tecnología RA en un sistema
abierto como Ubuntu, además, con la compilación y modificación de las librearías
ARToolKit fue posible comprender como es el funcionamiento de la tecnología
desarrollada por Hirokazo, el proyecto TApir logra de manera efectiva mostrar
herramientas de RA de forma practica mostrando una interfaz, aunque austera,
Capítulo 5. Conclusión y Aplicaciones Futuras
72
marca una simplicidad en el manejo RA de forma fácil y concreta para un usuario
final.
Con el proyecto TApir es posible apreciar la complejidad y estructura de los
algoritmos de la ARToolKit la cual es muy impresionante, pero continua con
limitaciones ya que solo trabaja con dos canales de color y por consecuente es
muy fácil que los marcadores se vean afectados por ruido externo dado a lo que
acontece en los capítulos III y IV de este documento puede plasmarse la potente
estructura de los algoritmos utilizados además de los programas integradores que
convergen en TApir.
Esta claro que para la instalación de TApir en un equipo diferente sea factible, es
necesaria la instalación de paquetes deb desde una terminal, además de una
librería que solo es posible instalarla desde repositorio con asistencia hacia
internet, esto representa un inconveniente para el usuario final, familiarizado con
sistemas Windows, en donde la simplicidad de instalar aplicaciones es suficiente
con pulsar doble click sobre el paquete de instalación. Aunque la instalación de
TApir es muy sencilla, los usuarios solo desean simplicidad, esto es una limitación
al proyecto muy marcada para hacer llegar TApir al usuario, pero proyecto busca
extenderse hacia el código abierto, dado a que, por esta vía el proyecto puede
crecer y madurar como aplicación.
En el énfasis hacia las limitaciones de TApir, otra limitante de gran importancia es
que el proyecto solo es funcional en arquitecturas x86, puesto que los paquetes
están construidos para ese tipo de sistemas, ahora, el compilar los programas de
ARToolKit en arquitecturas x64 no es factible para TApir, puesto que, las
dependencias que crean la portabilidad al proyecto, están construidas para uso
exclusivo de arquitecturas x86.
TApir aun es un aplicación que no refleja una tarea fija, actualmente su finalidad es
mostrar modelos y presentándoselos a un usuario, pero no implementan una tarea
especifica, además, su base del conocimiento es muy limitada, este es el limite de
Capítulo 5. Conclusión y Aplicaciones Futuras
73
este documento, pero el proyecto aun no termina la iniciativa esta definida los
campos y métodos en los que se puede aplicar la tecnología son vastos, la
tecnología de hardware cada vez es mas potente y accesible, la propuesta para
mejorar el proyecto esta abierta a cambios tanto de hardware como métodos.
5.2. Tendencias y problemas
Gracias a la popularidad cada vez mayor de aplicaciones de Realidad Aumentada
está tecnología comienza a salir de las tinieblas y a colarse en la cultura popular.
Lo que antes era una tecnología experimental para técnicos expertos, en la
actualidad se está convirtiendo en algo cada vez más accesible tanto para
desarrolladores como para consumidores de estas experiencias.
Los desarrollos para la implementación de RA son muy amplios los cuales
abarcan entrenamiento, localización, información, marketing entre muchos otros la
tendencia de este tipo de tecnología es llevarla al usuario final para que se logre
integrar en su vida diaria, ya sea desde una simple tarea como un juego de video
o hasta brindarle información de algún sitio desconocido; y con la intervención de
equipos celulares, cercanos a el rendimiento de una computadora, la idea de
utilizar aplicaciones en dispositivos móviles es más acertada, en todo caso TApir
aun pretende buscar una notoriedad en donde pueda desembocar de manera
fluida, las aéreas de énfasis son vastas, pero el proyecto aun es experimental, es
necesario indagar a profundidad en cuanto a los métodos de detección de marcas.
TApir en un principio considero la posibilidad de brindar una herramienta educativa
orientada hacia el nivel primaria, pero para lograr una herramienta con un
propósito especifico es necesario comprender la tecnología en donde se desea
aplicar, claro que es importante definir los alcances del proyecto, pero la
tecnología de RA no es una herramienta para subestimar, a diferencia de
herramientas integradoras para crear software educativo, la RA y en especifico el
proyecto TApir es una integración de tecnologías aunque no educativas, el
Capítulo 5. Conclusión y Aplicaciones Futuras
74
potencial que tiene el proyecto aun es muy prematuro para ser una herramienta
que maneje una tarea especifica como es un material didáctico o software
educativo.
Los principales problemas para alcanzar las tecnologías de la RA son los costos
tanto para el desarrollo como el hardware necesario para el buen funcionamiento.
El desarrollo de aplicaciones en RA va en crecimiento, pero el hardware necesario
aun se encuentra un poco retrasado a esta tecnología, se debe resaltar que con el
hardware actual es posible la creación de aplicaciones de RA, pues TApir es la
prueba de ello, pero aun el rendimiento es un poco deseable computacionalmente,
tanto en arquitectura del equipo como para el sistema operativo.
Bibliografía y Referencias Electrónicas
Bibliografía y Referencias Electrónicas
Bibliografía y Referencias Electrónicas
77
[1] Azuma, Ronald, “Computer graphics and scientific visualization”
http://www.cs.unc.edu/~azuma/azuma_AR.html recuperado el 17 de
diciembre de 2011.
[2] Bajura, M. Neumann, U, “Dynamic registration correction in video-based
augmented reality systems”, Computer Graphics & Applications, volume
15, page 52, North Carolina, 1995.
[3] Burdell, George P.” Biography of Ivan E. Sutherland,”
http://www.cc.gatech.edu/classes/cs6751_97_fall/projects/abowd_team/iva
n/ivan.html, recuperado 12 de noviembre 2010.
[4] Cohen, Michael, “Augmented reality”, www. csun . edu / cod / conf / 1994 /
proceedings / Aar ~ 1 . htm, recuperado 15 de noviembre de 2010.
[5] Comunidad RA, “logo AR”, http://augmentedrealitylogo.com/, recuperado
15 de noviembre de 2010.
[6]
Coto, Manuel Alonso,”LA REALIDAD AUMENTADA REFUERZA EL E-
COMMERCE”, http://marketing.blogs.ie.edu/archives/2010/10/la-realidad-
aumentada-refuerza-el-e-commerce.php, recuperado el 13 de enero de
2012.
[7] DiVerdi, S. Nurmi, D. Hollerer, “Augmented Reality Toolkit Workshop”, T.
Dept. of Comput. Sci., California Univ., Santa Barbara, CA, USA, 2003
[8] Feiner, S.K, “Adding insight through animation in augmented reality”,
Computer Animation '96. Proceedings, pagina 14, New York, 1996.
[9] Feiner, S, “Augmented reality: an application of heads-up display
technology to manual manufacturing processes ”System Sciences.
Proceedings of the Twenty-Fifth Hawaii International Conference on, 1992.
[10] Feiner, S, “Virtual worlds for visualizing information”, Supercomputing '92.
Bibliografía y Referencias Electrónicas
78
Proceedings, page 638, New York 1992.
[11] Flippo, Michael, “Realidad aumentada Aplicación Militar”,
http://www.solutekcolombia.com/realidad_aumentada_aplicacion_militar.ht
m, recuperado el 10 de enero de 2012.
[12] Friz, H. Elzer, P. Dalton, B. Taylor, “Augmented reality in internet
telerobotics using multiple monoscopic views”, K. Inst. for Process &
Production Control Tech., page 354, Tech. Univ. Clausthal, Germany,1998.
[13] Hernández V, Agustín, “Entrevista a desarrolladores sobre Realidad
Aumentada”, Pachuca Hgo, 2010.
[14] Hernández V, Agustín y Pérez G, Hiram, “interfaceT.py”, script Python para
interfaz de TApir, agosto de 2010.
[15] Hieronymi, Andrew, “Myron Krueger” http:// classes. dma. ucla. edu/
Winter04/ 256/ projects/ andrew/ report.html, recuperado 12 de noviembre
2010.
[16] Kutulakos, K.N. Vallino, J, ”Affine object representations for calibration-free
augmented reality”, Virtual Reality Annual International Symposium, 1996.,
Proceedings of the IEEE 1996, page 25,New York, 1996.
[17] Kim, D. Richards, S.W. Caudell, T.P, ”An optical traker for augmented
reality and wearable computers”, Virtual Reality Annual International
Symposium, 1997., IEEE 1997,page 146, Seattle, 1997.
[18] Kutulakos, K.N. Vallino, J.R., “Visualization and Computer Graphics”, IEEE
Transactions, 1998
[19] Lamb, Philip, “ARToolKit Tools”, http://www.hitl.washington.edu/ARToolKit/,
recuperado 15 de noviembre de 2010.
[20] Lanier, Jaron,” Jaron Lanier”, http://www.jaronlanier.com/, recuperado 12
Bibliografía y Referencias Electrónicas
79
de noviembre 2010.
[21] Lauro Soto, ”Introducción a la Graficación por computadora”, Publicado
1999, www. mitecnologico .com /Main/ Introduccion A La Graficacion Por
Computadora, recuperado 12 de noviembre de 2010.
[22] Leventon, Michael, “Project on Image Guided Surgery:A collaboration
between the MIT AI Lab and Brigham and Women's Surgical Planning
Laboratory”,http: // www . ai . mit . edu / projects / medical – visión / surgery
/ surgical _ navigation .html, recuperado el 20 de Diciembre de 2011.
[23] Lyu, M.R.; King, I.; Wong, T.T.; Yau, E.; Chan, P.W.,” ARCADE:
Augmented Reality Computing Arena for Digital Entertainment”, Aerospace
Conference, 2005 IEEE, page 1 – 9, Dept. of Comput. Sci. & Eng., Chinese
Univ. of Hong Kong, 2005
[24] Malkawi, A.; Srinivasan, R.; Jackson, B.; Yun Yi; Kin Chan; Angelov,
S., “Interactive, immersive visualization for indoor environments: use of
augmented reality, human-computer interaction and building simulation”,
Information Visualisation, 2004. IV 2004. Proceedings. Eighth International
Conference , page 833 – 838, Dept. of Archit., Pennsylvania Univ.,
Philadelphia, PA, USA, 2004
[25] metaioAR, “LEGO DIGITAL BOX - augmented reality kiosk system”,
http://www.youtube.com/watch?v=mUuVvY4c4-A, recuperado el 10 de
enero de 2012.
[26] Mizell, D.W, “Virtual reality and augmented reality in aircraft design and
manufacturing”, Res. & Technol, page 91, Seatle, WA, 1994.
[27] Milgram, P. rastogi, A. Grodski, J.J, “Telerobotic control using augmented
reality”, Robot and Human Communication, page 21, Toronto, 1995.
[28] Milgram, P. rastogi, F. Kishino, “Virtuality Continuum”,
http://erealityhome.wordpress.com/2008/10/18/paul-milgram-and-fumio-
Bibliografía y Referencias Electrónicas
80
kishino-virtuality-continuum/, recuperado el 17 de diciembre de 2011.
[29] Nintendo,”Juegos RA”, http : / /www. Nintendo . es / NOE / es _ ES / juegos
_ra_la_realidad_aumentada_32271.html, recuperado el 9 de enero de
2012.
[30] Rekimoto, Jun, “Augment-able Reality:Situated Communication through
Physical and Digital Spaces”, Sony Computer Science Laboratory, 1997
[31] Rolf R. Hainich. "El fin de Hardware: Un nuevo enfoque a la Realidad
Aumentada", 2 ª ed.: Booksurge, 2006. ISBN 1-4196-5218-4. 3 ª ed.
("Realidad Aumentada y más allá"): Booksurge, 2009.
[32] Son-Lik Tang Chee-Keong Kwoh Ming-Yeong Teo Ng Wan Sing Keck-Voon
Ling Nanyang, “Augmented reality systems for medical applications”,
Technol. Univ., Engineering in Medicine and Biology Magazine, page 49,
Singapore, 1998.
[33]
Torres, José Ignacio, “PRISMA: Aumentando la realidad”,http: // www.
realidad aumentada. es/ E l%20 proyecto%20 ventajas%20 y%20
objetivos.html, recuperado el 13 de Junio de 2011.
[34] Thomas, B. Demczuk, V. Piekarski, W. Hepworth, D. Gunther, “A Wearable
Computer”, Digest of Papers. Second International Symposium on, pagina
168, Univ. of South Australia, 1998.
[35] Travel, Marianne, “The father of virtual reality”,
http://www.mortonheilig.com/, recuperado 12 de noviembre de 2010.
Glosario
Glosario
Glosario
83
Applet.- componente de una aplicación
que se ejecuta en el contexto de otro
program. A diferencia de un programa,
un applet no puede ejecutarse de
manera independiente, ofrece
información gráfica y a veces interactúa
con el usuario, típicamente carece de
sesión y tiene privilegios de seguridad
restringidos. Un applet normalmente
lleva al cabo una función muy específica
que carece de uso independiente.
ARToolKit.- biblioteca que permite la
creación de aplicaciones de realidad
aumentada, en las que se sobrepone
imágenes virtuales al mundo real. Para
ello, utiliza las capacidades de
seguimiento de vídeo, con el fin de
calcular, en tiempo real, la posición de la
cámara y la orientación relativa a la
posición de los marcadores físicos. Una
vez que la posición de la cámara real se
sabe, la cámara virtual se puede colocar
en el mismo punto y modelos 3d son
sobrepuestos exactamente sobre el
marcador real. Así ARToolKit resuelve
dos de los principales problemas en la
realidad aumentada, el seguimiento de
punto de vista y la interacción objeto
virtual
BSD.- licencia de software otorgada
principalmente para los sistemas BSD
(Berkeley Software Distribution). Es una
licencia de software libre permisiva como
la licencia de OpenSSL o la MIT License.
Esta licencia tiene menos restricciones
en comparación con otras como la GPL
estando muy cercana al dominio público.
La licencia BSD al contrario que la GPL
permite el uso del código fuente en
software no libre.
C.- C es un lenguaje de programación
creado en 1972 por Dennis M. Ritchie en
los Laboratorios Bell como evolución del
anterior lenguaje B, a su vez basado en
BCPL.
Al igual que B, es un lenguaje orientado
a la implementación de Sistemas
Operativos, concretamente Unix. C es
apreciado por la eficiencia del código que
produce y es el lenguaje de
programación más popular para crear
software de sistemas, aunque también
se utiliza para crear aplicaciones.
C++.- C++ es un lenguaje de
programación diseñado a mediados de
los años 1980 por Bjarne Stroustrup. La
intención de su creación fue el extender
al exitoso lenguaje de programación C
con mecanismos que permitan la
manipulación de objetos. En ese sentido,
desde el punto de vista de los lenguajes
orientados a objetos, el C++ es un
lenguaje híbrido.
Posteriormente se añadieron facilidades
de programación genérica, que se sumó
a los otros dos paradigmas que ya
Glosario
84
estaban admitidos (programación
estructurada y la programación orientada
a objetos). Por esto se suele decir que el
C++ es un lenguaje de programación
multiparadigma.
CAD.- diseño asistido por computadora,
más conocido por sus siglas inglesas
CAD (computer-aided design), es el uso
de un amplio rango de herramientas
computacionales que asisten a
ingenieros, arquitectos y a otros
profesionales del diseño en sus
respectivas actividades.
CCD.- charge-coupled device o CCD (en
español «dispositivo de carga acoplada»)
es un circuito integrado que contiene un
número determinado de condensadores
enlazados o acoplados. Bajo el control
de un circuito interno, cada condensador
puede transferir su carga eléctrica a uno
o a varios de los condensadores que
estén a su lado en el circuito impreso. La
alternativa digital a los CCD son los
dispositivos CMOS (complementary
metal oxide semiconductor) utilizados en
algunas cámaras digitales y en
numerosas cámaras web. En la
actualidad los CCD son mucho más
populares en aplicaciones profesionales
y en cámaras digitales.
Codecs.- codificador-decodificador.
Describe una especificación desarrollada
en software, hardware o una
combinación de ambos, capaz de
transformar un archivo con un flujo de
datos (stream) o una señal. Los códecs
pueden codificar el flujo o la señal (a
menudo para la transmisión, el
almacenaje o el cifrado) y recuperarlo o
descifrarlo del mismo modo para la
reproducción o la manipulación en un
formato más apropiado para estas
operaciones. Los códecs son usados a
menudo en videoconferencias y
emisiones de medios de comunicación.
Deadlock.- En sistemas operativos, el
bloqueo mutuo (también conocido como
interbloqueo, traba mortal, deadlock,
abrazo mortal) es el bloqueo permanente
de un conjunto de procesos o hilos de
ejecución en un sistema concurrente que
compiten por recursos del sistema o bien
se comunican entre ellos. A diferencia de
otros problemas de concurrencia de
procesos, no existe una solución general
para los interbloqueos.
Debian.- Debian es un sistema operativo
(S.O.) libre, para su computadora. El
sistema operativo es el conjunto de
programas básicos y utilidades que
hacen que funcione su computadora.
Debian utiliza el núcleo Linux (el corazón
del sistema operativo), pero la mayor
parte de las herramientas básicas vienen
del Proyecto GNU; de ahí el nombre
Glosario
85
GNU/Linux.
Display.- Se llama visualizador, display
en inglés, a un dispositivo de ciertos
aparatos electrónicos que permite
mostrar información al usuario de
manera visual. Un visualizador de una
señal de video se lo llama más
comúnmente pantalla; los dos ejemplos
más comunes son el televisor y el
Monitor de computadora. Un visualizador
es un tipo de dispositivo de salida.
E-commerce.- El comercio electrónico,
también conocido como e-commerce
(electronic commerce en inglés), consiste
en la compra y venta de productos o de
servicios a través de medios
electrónicos, tales como Internet y otras
redes informáticas. Originalmente el
término se aplicaba a la realización de
transacciones mediante medios
electrónicos tales como el Intercambio
electrónico de datos, sin embargo con el
advenimiento de la Internet y la World
Wide Web a mediados de los años 90
comenzó a referirse principalmente a la
venta de bienes y servicios a través de
Internet, usando como forma de pago
medios electrónicos, tales como las
tarjetas de crédito.
Fedora.- es una distribución Linux para
propósitos generales basada en RPM,
que se caracteriza por ser un sistema
estable, la cual es mantenida gracias a
una comunidad internacional de
ingenieros, diseñadores gráficos y
usuarios que informan de fallos y
prueban nuevas tecnologías. Cuenta con
el respaldo y la promoción de Red Hat.
Firefox.- navegador web libre y de
código abierto descendiente de Mozilla
Application Suite y desarrollado por la
Fundación Mozilla.
Frame.- Se denomina frame en inglés, a
un fotograma o cuadro, una imagen
particular dentro de una sucesión de
imágenes que componen una animación.
La continua sucesión de estos
fotogramas producen a la vista la
sensación de movimiento, fenómeno
dado por las pequeñas diferencias que
hay entre cada uno de ellos.
Framework.- En el desarrollo de
software, un framework o infraestructura
digital, es una estructura conceptual y
tecnológica de soporte definido,
normalmente con artefactos o módulos
de software concretos, con base a la cual
otro proyecto de software puede ser más
fácilmente organizado y desarrollado.
Típicamente, puede incluir soporte de
programas, bibliotecas, y un lenguaje
interpretado, entre otras herramientas,
para así ayudar a desarrollar y unir los
diferentes componentes de un proyecto.
Glosario
86
Fudicial Points.- Un marcador de
referencia o fiducial es un objeto que se
utiliza en el campo de visión de un
sistema de imagen que aparece en la
imagen producida, su uso es tomar como
punto de referencia. Puede ser algo o
bien colocar sobre la imagen alguna
marca o conjunto de marcas que puedan
se detectadas por la retícula de un
instrumento óptico.
GCC.- GNU Compiler Collection
(colección de compiladores GNU) es un
conjunto de compiladores creados por el
proyecto GNU. GCC es software libre y
lo distribuye la FSF bajo la licencia GPL.
GDM.- (GNOME Display Manager) es un
gestor de acceso para el X Window
System. Es el reemplazo, elaborado por
el proyecto GNOME, al XDM básico.
GDM permitía a los usuarios personalizar
el gestor hasta versión 2.30.0,
renombrada como gdm3. También
permite solucionar problemas de su
configuración sin tener que recurrir a la
línea de comandos y gestionar la entrada
a otros entornos de escritorio. La gran
cantidad de dependencias de gdm3
frente a gdm hace de este algo mas
pesado que su predecesor, mas no así
su rendimiento, que no se nota gran
diferencia en equipos modernos.
GNOME.- entorno de escritorio e
infraestructura de desarrollo para
sistemas operativos Unix y derivados
Unix como GNU/Linux, BSD o Solaris;
compuesto enteramente de software
libre.
GPS.- El SPG o GPS (Global Positioning
System: sistema de posicionamiento
global) o NAVSTAR-GPS1 es un sistema
global de navegación por satélite (GNSS)
que permite determinar en todo el mundo
la posición de un objeto, una persona o
un vehículo con una precisión hasta de
centímetros (si se utiliza GPS
diferencial), aunque lo habitual son unos
pocos metros de precisión.
GTK+.- conjunto de bibliotecas
multiplataforma para desarrollar
interfaces gráficas de usuario (GUI),
principalmente para los entornos gráficos
GNOME, XFCE y ROX aunque también
se puede usar en el escritorio de
Windows, MacOS y otros.
GtkBuilder.- es un objeto auxiliar que
lee descripciones textuales de una
interfaz de usuario y crea instancias de
los objetos descritos.
GUI.- interfaz gráfica de usuario,
conocida también como GUI (del inglés
graphical user interface) es un programa
informático que actúa de interfaz de
usuario, utilizando un conjunto de
Glosario
87
imágenes y objetos gráficos para
representar la información y acciones
disponibles en la interfaz. Su principal
uso, consiste en proporcionar un entorno
visual sencillo para permitir la
comunicación con el sistema operativo
de una máquina o computador.
HMD.- dispositivo de visualización similar
a un casco, que permite reproducir
imágenes creadas por comṕutadora
sobre un "display" muy cercano a los
ojos o directamente sobre la retina de los
ojos. En este segundo caso el HMD
recibe el nombre de monitor virtual de
retina.
IEEE.- corresponde a las siglas de
(Institute of Electrical and Electronics
Engineers) en español Instituto de
Ingenieros Eléctricos y Electrónicos, una
asociación técnico-profesional mundial
dedicada a la estandarización, entre
otras cosas.
Joystick.- dispositivo de control de dos o
tres ejes que se usa desde una
computadora o videoconsola hasta un
transbordador espacial o los aviones de
caza, pasando por grúas.
Kernel.- núcleo o kernel (de la raíz
germánica Kern) es un software que
constituye la parte más importante del
sistema operativo. Es el principal
responsable de facilitar a los distintos
programas acceso seguro al hardware
de la computadora o en forma básica, es
el encargado de gestionar recursos, a
través de servicios de llamada al
sistema. Como hay muchos programas y
el acceso al hardware es limitado,
también se encarga de decidir qué
programa podrá hacer uso de un
dispositivo de hardware y durante cuánto
tiempo, lo que se conoce como
multiplexado. Acceder al hardware
directamente puede ser realmente
complejo, por lo que los núcleos suelen
implementar una serie de abstracciones
del hardware. Esto permite esconder la
complejidad, y proporciona una interfaz
limpia y uniforme al hardware
subyacente, lo que facilita su uso al
programador.
LEGO.- empresa de juguetes danesa
reconocida principalmente por sus
bloques de plástico interconectables.
Linux.- es un núcleo libre de sistema
operativo basado en Unix.2 Es uno de
los principales ejemplos de software
libre. Linux está licenciado bajo la GPL
v2 y está desarrollado por colaboradores
de todo el mundo. El desarrollo del día a
día tiene lugar en la Linux Kernel Mailing
List Archive
MacOS.- sistema operativo creado por
Glosario
88
Apple para su línea de computadoras
Macintosh. Es conocido por haber sido el
primer sistema dirigido al gran público en
contar con una interfaz gráfica
compuesta por la interacción del mouse
con ventanas, Icono y menús.
Melt Banana.- banda de noise rock
originaria de Japón, fundada en 1992 en
Tokio por Yasuko Onuki.
Monoscópicas.- aquellos en los que el
operador sólo dispone de entradas de
profundidad monoculares, es decir
aquellas iguales para ambos ojos y
tienen la misma efectividad si son vistas
sólo por uno de ellos.
Mundo virtual.- simula un mundo o
entorno artificial inspirado o no en la
realidad, en el cual los usuarios pueden
interactuar entre sí a través de
personajes o avatares, y usar objetos o
bienes virtuales.
Nintendo.- empresa multinacional de
videojuegos.
Nintendo 3DS.- videoconsola portátil de
la multinacional de origen japonés,
Nintendo, para videojuegos y multimedia,
que puede reproducir imágenes en 3D
estereoscópicas sin la necesidad de
utilizar gafas.
No coplanares.- Son aquellas que se
encuentran en diferente plano y en 3 ejes
“x”, “y” y “z”.
Path.- Una ruta (en inglés path) es la
forma de referenciar un archivo
informático o directorio en un sistema de
archivos de un sistema operativo
determinado. Una ruta señala la
localización exacta de un archivo o
directorio mediante una cadena de
caracteres concreta. Ésta puede ser de
diversas formas dependiendo del
sistema operativo y del sistema de
archivos en cuestión. En líneas
generales se compondrá de los nombres
de los directorios que conforman el
camino hasta nuestro archivo o directorio
a lo largo del árbol de directorios, y
finalmente estará el nombre del archivo o
directorio que se quiere referenciar.
Estos nombres estarán separados por un
carácter delimitador que usualmente será
"\" en sistemas MS-DOS/Windows
(Microsoft) o "/" en sistemas UNIX/Linux.
Pixel.- n píxel o pixel, plural píxeles
(acrónimo del inglés picture element,
"elemento de imagen") es la menor
unidad homogénea en color que forma
parte de una imagen digital, ya sea esta
una fotografía, un fotograma de vídeo o
un gráfico.
Plug-in.- Un complemento es una
Glosario
89
aplicación que se relaciona con otra para
aportarle una función nueva y
generalmente muy especifica. Esta
aplicación adicional es ejecutada por la
aplicación principal e interactúan por
medio de la API. También se lo conoce
como plug-in (del inglés "enchufable"),
add-on (agregado), complemento,
conector o extensión.
Scripts.- guión, archivo de órdenes o
archivo de procesamiento por lotes,
vulgarmente referidos con el barbarismo
script, es un programa usualmente
simple, que por lo regular se almacena
en un archivo de texto plano. Los
guiones son casi siempre interpretados,
pero no todo programa interpretado es
considerado un guión. El uso habitual de
los guiones es realizar diversas tareas
como combinar componentes, interactuar
con el sistema operativo o con el usuario.
Por este uso es frecuente que los shells
sean a la vez intérpretes de este tipo de
programas.
SGI IRIX.- sistema operativo compatible
con Unix, creado por Silicon Graphics
para su plataforma MIPS de 64 bits.
IRIX tiene un particular soporte para
gráficos 3D, video y transferencia de
datos de gran ancho de banda. Fue una
de las primeras versiones de Unix en
tener una interfaz gráfica de usuario
(GUI) para el escritorio principal y es
actualmente ampliamente utilizado,
debido a su extremadamente alta calidad
en gráficos 3D, en la industria de la
animación por computadora y para
visualización científica.
Shell.- Una Shell de Unix o también
shell, es el término usado en informática
para referirse a un intérprete de
comandos, el cual consiste en la interfaz
de usuario tradicional de los sistemas
operativos basados en Unix y similares
como GNU/Linux. Mediante las
instrucciones que aporta el intérprete, el
usuario puede comunicarse con el
núcleo y por extensión, ejecutar dichas
órdenes, así como herramientas que le
permiten controlar el funcionamiento de
la computadora. Los comandos que
aportan los intérpretes, pueden usarse a
modo de guion si se escriben en ficheros
ejecutables denominados shell-scripts,
de este modo, cuando el usuario
necesita hacer uso de varios comandos
o combinados de comandos con
herramientas, escribe en un fichero de
texto marcado como ejecutable, las
operaciones que posteriormente, línea
por línea, el intérprete traducirá al núcleo
para que las realice. Sin ser un shell
estrictamente un lenguaje de
programación, al proceso de crear scripts
de shell se le denomina programación
shell o en inglés, shell programming o
shell scripting.
Glosario
90
Smartphones.- término comercial para
denominar a un teléfono móvil que ofrece
la posibilidad de instalación de
programas para incrementar el
procesamiento de datos y la
conectividad.
Synaptic.- programa informático que es
una interfaz gráfica GTK+ de APT, para
el sistema de gestión de paquetes de
Debian GNU/Linux. Generalmente se
utiliza Synaptic para sistemas basados
en paquetes .deb pero también puede
ser usado en sistemas basados en
paquetes RPM.
Ubuntu.- sistema operativo mantenido
por Canonical y la comunidad de
desarrolladores. Utiliza un núcleo Linux,
y su origen está basado en Debian.
Ubuntu está orientado en el usuario
promedio, con un fuerte enfoque en la
facilidad de uso y mejorar la experiencia
de usuario. Está compuesto de múltiple
software normalmente distribuido bajo
una licencia libre o de código abierto.
Usb.- Universal Serial Bus (bus universal
en serie USB) es un estándar industrial
desarrollado en los años 1990 que define
los cables, conectores y protocolos
usados en un bus para conectar,
comunicar y proveer de alimentación
eléctrica entre ordenadores y periféricos
y dispositivos electrónicos.
Windows.- nombre de una familia de
sistemas operativos desarrollados por
Microsoft desde 1981, año en que el
proyecto se denominaba «Interface
Manager».
Wireframe.- Algoritmo de renderización
del que resulta una imagen
semitransparente, de la cual solo se
dibujan las aristas de la malla que
constituye al objeto. De ahí su nombre.
Casi nunca se emplea en la
representación final de una imagen, pero
sí en su edición, debido a la escasa
potencia de cálculo necesaria
(comparada con otros métodos).
Para conseguir una imagen en wireframe
solo tenemos que tener en cuenta las
posiciones de los puntos en el espacio
tridimensional y las uniones entre ellos
para formar los polígonos.
Habitualmente estas imágenes no tienen
en cuenta la presencia de luces en la
escena.
Xml.- siglas en inglés de eXtensible
Markup Language ('lenguaje de marcas
extensible'), es un metalenguaje
extensible de etiquetas desarrollado por
el World Wide Web Consortium (W3C).
Es una simplificación y adaptación del
SGML y permite definir la gramática de
lenguajes específicos (de la misma
manera que HTML es a su vez un
lenguaje definido por SGML).
Apéndice A
Apéndice A.
Apéndice A
iii
A1. Manual para el uso de TApir
La interfaz de TApir cuenta con 13 botones que realizan tareas de RA que van
desde prueba de video hasta la incrustación de 4 modelos tridimensionales, Figura
34.
Figura 34. Interfaz TApir.
.
Los marcadores utilizados en TApir se muestran en la Figura 35.
Figura 35. Marcadores utilizados por TApir.
Apéndice A
iv
A1.1. Requerimientos del Sistema
Es posible el correcto funcionamiento en computadoras de escritorio y portátiles
con sistema operativo Ubuntu; funcional desde la versión 9.04 hasta la 11.10 es
posible su instalación en versiones superiores siempre y cuando utilicen entorno
GDM.
Características de hardware:
Procesador a 1.6GZ mínimo.
Memoria RAM de 2GB mínimo.
Cámara web de 1.3 mpx mínimo.
A1.2. Instalación
Para la instalación de TApir se debe instalar los paquetes libopenvrml4_0.14.3-
3_i386.deb, libstdc++5_13a3.3.6-17ubuntu1_i386.deb y por medio de un
repositorio freeglut, para posteriormente desempaquetar el contenedor del
programa llamado TApir.tar.gz en la carpeta principal del usuario.
Se puede crear un acceso directo para llamar el programa, para ello en el
escritorio (esto es para entornos GDM) se pulsa el botón secundario del mouse
para posteriormente elegir “crear un lanzador” al crearlo se mostrará una ventana
en donde se incluirá un comando en código Python para llamar a la interfaz gráfica
de TApir el comando se inserta en la sección de la ventana que dice “comando” el
cual es “Python /home/usuario/.TApir0.4beta/bin/interfaceT.py” (Figura 36).
Apéndice A
v
Figura 36. Ventana para crear un lanzador.
A1.3. Características de los algoritmos
Una vez que se ha creado el lanzador basta con hacer doble click sobre él para
invocar la interfaz. A continuación se describe el funcionamiento de los botones.
Prueba de webcam: realiza una prueba de la cámara comprobando la
funcionalidad y presencia de la misma.
Prueba de gráficos: realiza el renderizado por medio de GLUT una tetera para
comprobar que el motor de renderizado funciona perfectamente.
Rangetest: reconoce formas cuadradas en el ambiente.
Pall: incrusta sobre el patrón HIRO un círculo alrededor del marcador y marca con
un color rojo el límite del mismo.
Relationtest: realiza el renderizado de una esfera y un cubo en los marcadores
HIRO y KANJI.
Simplelite: renderiza un cubo con texturas gradiales.
Apéndice A
vi
Simpletest: renderiza un cubo.
Marcador: crea nuevos marcadores para usarlos en las aplicaciones de RA.
Collitetest: renderiza esfera, cubo, cono y dona.
Exview: muestra las coordenas que arroja un patrón.
Loadmultiple: renderiza modelos simples en pantalla completa.
Modetest: renderiza modelos simples y al pulsar la tecla “d” presenta el modo
umbral, modo de video normal y la integración de modelos 3D.
RA insectos: muestra el renderizado de 4 modelos de insectos.
A2. Problemas de ejecución al lanzar TApir
Si en caso que la aplicación no responda de manera correcta se pueden aplicar
diferentes alternativas para solucionar el problema.
Problemas al cerrar la aplicación
Si al pulsar un botón de acción en TApir, no realiza acción alguna, el botón
perteneciente a la ventana cerrar no funciona y TApir muestra un color gris,
significa que la aplicación encontró con un deadlook.
Terminar proceso usando la terminal del sistema
La solución es “matar” el proceso mediante el uso de una terminal, en la cual
se escribe el comando “ps –A” la terminal despliega todos los procesos
activos, basta con identificar el proceso llamado Python y verificar su código de
Apéndice A
vii
referencia para ejecutar el comando “kill”, el cual termina el proceso (ver
Figura 37).
Figura 37. Terminar proceso usando una terminal.
Terminar proceso mediante el uso de un applet
El sistema operativo Ubuntu cuenta con applets los cuales tienen diferentes
funcionalidades; uno de estos applets es el que realiza la terminación de procesos
mediante un simple click, para obtenerlo a disposición basta con hacer click
secundario sobre el panel principal de Ubuntu y elegir añadir panel (Figura 38)
Figura 38. Ventana Añadir al panel.
Apéndice A
viii
Posteriormente se añade al panel el applet llamado “forzar la salida”.
Una vez que se haya añadido se mostrará un icono con una ventana rota sobre el
panel principal, ahora sólo basta pulsar el icono y desplegará un mensaje el cual
pide que se de click sobre la ventana o aplicación a terminar (Figura 39).
Figura 39. Forzar terminación.
Si la pantalla del equipo se congela y no se puede hacer uso de los métodos
anteriores para el cierre de la aplicación, se puede presionar el botón de
encendido por unos momentos para apagar el equipo, después iniciar sesión y si
el SO hace una petición de lógica en la estructura de datos se recomienda que no
se detenga para posteriormente ejecutar de nuevo la aplicación TApir.
Apéndice B
Apéndice B.
Apéndice B
xi
B1. Acerca de TApir
A continuación se muestran algunas imágenes representativas del proyecto TApir.
En la Figura 40 se muestra el lanzador que permite la ejecución de TApir, el
lanzador facilita llamar al proyecto.
Figura 40. Lanzador o acceso directo a TApir.
Al acceder al lanzador se despliega la interfaz el proyecto, ver Figura 41.
Figura 41. Interfaz TApir.
Apéndice B
xii
TApir cuenta con un menú desplegable que muestra el “Acerca de TApir” y créditos
de los desarrolladores, Figura 42.
Figura 42. Ventana "Acerca de TApir".
B2. Algoritmos TApir
TApir consta de diversos algoritmos que, de acuerdo a su base del conocimiento,
detecta los marcadores en los que se deben integrar los modelos 3D, Figura 43.
Figura 43. Programa simpletest.c.
Apéndice B
xiii
En la Figura 44 se muestra la primera conexión hecha en Python usando una
interfaz; la interfaz es solo un piloto para el diseño de interfaz de usuario.
Figura 44. Piloto de la interfaz final y prueba de conexiones.
Las pruebas en el programa modificado simpleVRML.c parecen tener buen
funcionamiento, ver Figuras 45, 46 y 47.
Figura 45. Algoritmo RA que reconoce un patrón y renderiza un grillo.
Apéndice B
xiv
Figura 46. Renderizado de 2 modelos sobre video en directo.
Figura 47. Mosca incrustada sobre video en directo