Herramientas ARToolKit Implementadas en el Proyecto de Realidad Aumentada TApir para Sistemas...

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


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.


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”.


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.


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.


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


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.


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.


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


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.


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


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.


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


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


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


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


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


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


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.


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.


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.


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.


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


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].


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


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.


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.


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.


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


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.


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


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


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.


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.


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.


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.


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


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


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


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.


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:


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.


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.


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.


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


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.


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.


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:


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


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.


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.


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.


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.


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.


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.


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.


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


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


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


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.


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,


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


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


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



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.

http://www.csun.edu/cod/conf/1994/proceedings/Aar~1.htm



http://augmentedrealitylogo.com/


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

http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=3517



http://www.jaronlanier.com/


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-


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.

http://www.mortonheilig.com/

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

Herramientas ARToolKit Implementadas en el Proyecto de Realidad Aumentada TApir para Sistemas...

Investor Relations

Transcript of Herramientas ARToolKit Implementadas en el Proyecto de Realidad Aumentada TApir para Sistemas...