Creación de ambientes virtuales automáticamente

tomando fotografías con un robot móvil

1 Introducción ...............................................................................................4
2 Marco teórico .............................................................................................6
2.1 Robots móviles...................................................................................6
2.1.1 Interpretación de los sensores ........................................................6
2.1.2 Razonamiento.................................................................................8
2.1.3 Arquitectura....................................................................................9
2.1.4 El robot tx8...................................................................................12
2.2 Lenguajes de programación .............................................................14
2.2.1 Introducción a los lenguajes de programación.............................14
2.2.2 Sintaxis y semántica.....................................................................14
2.2.3 Características de un buen lenguaje de programación.................15
2.2.4 Consideraciones en el diseño de lenguajes ..................................16
2.2.5 Protocolos de red..........................................................................17
2.3 Ambientes virtuales..........................................................................18
2.3.1 La clasificación de Zeltzers de los ambientes virtuales ...............20
2.3.2 Render por imágenes....................................................................21
2.3.2.1 Fotografías panorámicas ......................................................22
2.3.2.2 Corrección gamma y distorsión de barril.............................24
2.3.2.2.1 Corrección gamma..........................................................24
2.3.2.2.2 Distorsión de barril (barrel distortion)............................25
2.4 Transformaciones en dos dimensiones ............................................26
2.4.1 Traslación .....................................................................................26
2.4.2 Rotación .......................................................................................26

1
 2.4.3 Composición de transformadas ....................................................27
3 Desarrollo .................................................................................................29
3.1 El lenguaje ROBEL..........................................................................29
3.1.1 Descripción del lenguaje ..............................................................30
3.1.1.1 Instrucciones del lenguaje....................................................30
3.1.2 Construcción del lenguaje ............................................................32
3.1.2.1 Descripción de la máquina virtual ExecuteCommand.........32
3.1.2.2 Descripción de la máquina virtual ReadCommand .............34
3.1.3 Análisis del lenguaje ....................................................................36
3.2 Campos potenciales..........................................................................37
3.2.1 Cálculo del campo potencial ........................................................39
3.2.2 Instrumentación............................................................................42
3.3 El ambiente virtual creado ...............................................................44
3.3.1 Definición del mundo virtual .......................................................44
3.3.1.1 Otros mundos virtuales creados con fotografías..................45
3.3.2 Herramientas utilizadas................................................................46
3.3.3 Creación de las fotografías panorámicas .....................................47
3.3.4 Desarrollo del programa de despliegue........................................48
3.3.4.1 Proyección de las imágenes .................................................49
3.3.5 Proceso de creación del mundo....................................................56
4 Conclusiones y resultados ........................................................................59
4.1 Propuestas para el mejoramiento de ROBEL ..................................59
4.2 Conclusiones sobre el mundo virtual ...............................................60
Apéndice A Configuración del programa robottx8......................................63
Apéndice B Interfaz de las máquinas virtuales............................................67

2
Apéndice C Descripción de la representación simbólica del mundo...........69
Apéndice D Programas en ROBEL..............................................................71
a) Salida del planeador .............................................................................71
b) Programa que toma las fotos ................................................................72
5 Bibliografía...............................................................................................73

3
Introducción

1 Introducción
En los últimos años se ha visto un incremento en la cantidad de mundos y
ambientes virtuales en un sinnúmero de aplicaciones. Estos mundos están
formados por imágenes generadas por la computadora (render1). Este método
tiene el problema que se debe de invertir una gran cantidad de tiempo –
hombre en el modelado y la construcción del mundo que se quiere simular.
Además existen lugares donde no se pueden utilizar imágenes creadas por
computadora para generar un ambiente virtual, como por ejemplo en los
museos o en las zonas arqueológicas [Seitz, McAllister].
Para corregir esto, se está desarrollando una técnica de graficación por
computadora, que consiste en utilizar imágenes fotográficas en vez de
imágenes creadas por computadora como una alternativa al dibujo de gráficas
por computadora tradicional, ya que cuenta con dos ventajas muy importantes:
se pueden mostrar mundos independientemente de su complejidad y se
simplifica el proceso de modelado del mundo. Uno de los principales
problemas contra los que se enfrenta esta técnica, es que la adquisición de los
datos, es decir las fotografías con las que se va a generar el mundo, es un
proceso muy tardado ya que se necesitan una gran cantidad de aquéllas, por lo
que se desea buscar una forma de automatizar el proceso. Para resolver este
problema se decidió utilizar un robot móvil, puesto que ayuda a tener un
control sobre la posición donde fueron tomadas las fotos así como a
automatizar el proceso de tomar las fotos, siendo ambos aspectos esenciales y
deseables en la creación del mundo virtual por medio de imágenes.
También, se está buscando una manera de mostrar mundos virtuales en
páginas Web. Por esta razón se decidió utilizar un applet2 en Java el cual por
su capacidad de ejecución en prácticamente todas las arquitecturas de
computadoras, el mundo virtual podrá ser visto fácilmente desde cualquier
navegador.
Para calcular las rutas que el robot debe seguir para tomar las fotografías se
utilizó la técnica de navegación conocida como campos potenciales de la cual
se hará una revisión en la tesis.

1
Render: proceso de creación de imágenes en una computadora.
2
Applet: programa diseñado para ser ejecutado dentro de otra aplicación, por ejemplo los
applets de Java se ejecutan dentro de un navegador de Internet.

4
Introducción

Para el control del robot móvil se utilizo el lenguaje ROBEL (RObot

BEhaivor Language) el cual fue diseñado en el laboratorio de Interfaces
Inteligentes para el control y manejo de robots móviles. En esta tesis también
se analizara el desempeño del lenguaje como herramienta para la realización
del trabajo y se formularán propuestas para su mejora. También se comentara
sobre la construcción que se hizo del lenguaje ROBEL para el robot B143.
El objetivo de la tesis es simular la navegación del robot B14 en el
Laboratorio de Interfaces Inteligentes, utilizando fotografías
panorámicas para lograr un ambiente con mayor realismo sin tener
que recurrir a procesos complejos de modelado.
Actualmente, las fotografías panorámicas son tomadas manualmente
o con la ayuda de un tripié y se tiene poco control sobre los ángulos
con los que se toman las fotos. Por esta razón es difícil crear las
panorámicas automáticamente, puesto que es necesario establecer
manualmente puntos de control y algunas veces es necesario retocar
el producto final. Esto hace que la creación de las fotografías
panorámicas sea un proceso tardado, caro y con la necesidad de
utilizar personal calificado. Lo que se intenta hacer es utilizar un
robot para controlar las posiciones de las fotografías y así crearlas de
una manera automática.

3
Ver el apartado 2.1.4 para una descripción del robot.

5
Marco teórico

2 Marco teórico
2.1 Robots móviles
Un robot móvil es un vehículo autónomo capaz de realizar movimientos y
acciones inteligentes sin la necesidad de ser teleoperado; para lograrlo debe de
ser capaz de:
• Sensar su entorno.
• Interpretar la información dada por los sensores para refinar el
conocimiento de su posición y del entorno.
• Planear una ruta desde una posición inicial hasta una posición meta, con
la presencia de obstáculos conocidos o desconocidos.
El principal problema de los robots móviles es hacer que actúen de la manera
deseada en ambientes donde el nivel de casualidades es muy alto. El
programar un robot cuando el control sobre el ambiente es alto, es una tarea
relativamente fácil que se va complicando en la medida en que se van
introduciendo casualidades. Se entiende como causalidad a todos los
elementos dentro del ambiente que varían; por ejemplo una silla es una
causalidad ya que ésta no se encuentra fija dentro del mundo sino que su
posición varía con respecto al tiempo.
El problema puede ser descompuesto en interpretar los datos de los sensores y
con estos datos generar acciones que lleven a realizar una tarea. Al realizar
esto se estará en condiciones de desarrollar robots capaces de trabajar en
grandes ambientes no controlados. Para lograrlo, las prioridades deben ser la
interpretación de los sensores y el razonamiento [Ingermar].

2.1.1 Interpretación de los sensores

El robot debe ser capaz de determinar su relación con el ambiente por medio
de sensores. A pesar que existe una gran cantidad de tecnologías para la
construcción de sensores: odómetros, ultrasonido, infrarrojo y láser así como
visión monocular, binocular, la dificultad se encuentra en saber lo que éstos
dicen sobre el mundo exterior. El problema principal radica en hacer la
interpretación de la señal dada por el sensor a lo que ésta significa en un
mundo tridimensional.

6
Marco teórico

Esencialmente todos los procesos que existen para la interpretación de la

información de los sensores consisten en identificar el conjunto de
propiedades en los datos del sensor que potencialmente corresponden a
características del mundo y con base en estos datos tratar de determinar una
descripción del mundo.
La experiencia muestra que el desempeño de cualquier sensor está
determinado en gran medida por su procesamiento después de que los datos
han sido adquiridos; por esto hay que tener esencial cuidado en el método de
procesamiento que se utilice para interpretar la señal de los sensores.
Otro problema importante a considerar para la interpretación de los sensores
es que tienen inherente cierto ruido que se debe tomar en cuenta para tener
lecturas útiles.
Para combatir estos problemas se utiliza una técnica llamada fusión de
sensores4 que consiste en la combinación de múltiples tipos de sensores o
múltiples observaciones del mismo objeto.
La principal función de los sensores es dar información para:
• Navegación o estimación de la posición.
• Detectar o esquivar obstáculos.
• Exploración en ambientes desconocidos.
Uno de los sensores más usados para mantener y controlar la posición del
robot es el odómetro. Su función es llevar el control de la distancia que ha
recorrida el robot para estimar su posición. Estos sensores tienen el problema
que el error crece conforme el robot va avanzando, por lo que en algunos
casos es necesario de un mecanismo que corrija la posición.
Dentro de los principales objetivos de la percepción es obtener una
representación simbólica a partir de los datos que adquiere de los sensores
internos o externos5.

4
En inglés esta técnicas se llama “sensor fusion”.
5
Los sensores internos son aquellos que miden el estado del robot, mientras que los
externos miden alguna característica del entorno.

7
Marco teórico

2.1.2 Razonamiento
El robot debe ser capaz de decidir qué acciones son requeridas para lograr sus
metas dentro de un ambiente dado. Esto significa tomar decisiones a partir de
los datos obtenidos de los sensores.
En el campo del razonamiento, los problemas principales son de naturaleza
geométrica (cómo elegir un buen camino o determinar dónde tomar un
objeto). Se han desarrollado muchas técnicas que resuelven estos problemas
cuando se cuenta con la información completa del entorno de trabajo, pero se
ha visto que el problema se vuelve más difícil cuando se introducen
imprevistos o casualidades. Dado que las casualidades son inherentes a los
robots móviles, se deben desarrollar métodos que permitan hacer estas tareas
en ambientes que no sean completamente controlados.
La solución consiste en utilizar la lectura de los sensores para mantener un
buen modelo de la situación real del entorno, pero dados los problemas que
presenta interpretar la información adquirida se han desarrollado robots que
minimizan la cantidad de lecturas que requieren. Como resultado la mayoría
de los robots operan prácticamente en lazo abierto6.
Por otro lado, para lograr buenos resultados en la etapa de razonamiento los
lenguajes procedurales ha demostrado un desempeño muy pobre, puesto que
estos lenguajes fueron diseñados para programas con poca interacción. Por
esta razón es necesario utilizar otra aproximación de lenguajes de
programación.
El plan de acción del robot para ambientes no estructurados debe estar en
función del mundo. Lo que conviene es crear un lazo de control7 mapeando las
lecturas de los sensores hacia los actuadores. El robot debe poseer una manera
de traducir los estados del mundo a metas, y después mapear estas metas a
acciones. La razón por la que los lazos de control tradicional no son buenos en
éstos casos, es porque son usados principalmente en sistemas lineales que se
pueden modelar por medio de ecuaciones, lo que da un sistema de cambios

6
Se llama sistema de lazo abierto a aquel en el que no existe una retroalimentación de la
salida a la entrada.
7
Se llama sistema de lazo de control ó de lazo cerrado a aquel en el que existe una
retroalimentación de la salida a la entrada, con el fin de corregir el error. Esto es la base de
la teoría de control.

8
Marco teórico

suaves donde un pequeño cambio en la entrada da pequeños cambios a la

salida, pero esto no es el caso de los robots móviles.

2.1.3 Arquitectura
Existen varias arquitecturas para el control de robots móviles; la utilizada aquí
se basa en la presentada en el proyecto Aura por Ronald Arkin [Arkin]. Esta
arquitectura consiste en varios módulos, Figura 1, cada un de ellos con una
función específica en el comportamiento del robot. La arquitectura propuesta
aquí fue modificada para soportar tanto robots virtuales como robots reales,
utilizando el lenguaje de programación ROBEL.

Figura 1 Arquitectura ViRBot (Virtual and Real Robot).

9
Marco teórico

En esta sección se explicarán algunos módulos de la arquitectura.

Percepción
Consiste en la adquisición e interpretación de los datos leídos por los sensores.
Simulación
Si se utiliza el robot virtual, es posible simular los valores de los sensores
aplicándoles un modelo físico, logrando una simulación más real de los datos
del entorno.
Interfaz hombre-robot
La comunicación entre el robot y el usuario es hecha en este módulo
utilizando técnicas de reconocimiento de voz, de imágenes o de texto.
Tareas del robot
El robot es programado para realizar ciertas tareas como trasladar objetos o
recoger basura. Este módulo es el encargado de asignar las tareas que el robot
realizará.
Modelo del entorno
Este módulo usa los datos obtenidos por la percepción y la información del
cartógrafo y del módulo de representación del conocimiento para generar un
modelo del entorno y generar soluciones a las situaciones que se presenten.
Cartógrafo
Para cada cuarto del entorno existe una representación de cómo están
interconectados los cuartos, además de la posición de los obstáculos que se
encuentran en cada cuarto8. Esta información es utilizada para la navegación
en el entorno.
Representación del conocimiento
El módulo de representación del conocimiento consta de un sistema experto
que contiene las acciones que se deben hacer para cada caso que se presente.
El programa que se utiliza para la creación de los sistemas expertos es una

8
Ver el Apéndice C para una descripción de la representación.

10
Marco teórico

versión de CLIPS especialmente modificado para utilizar comunicación por

medio de sockets9 y tener despliegue gráfico utilizando Tcl/Tk10.
CLIPS [Giarratano] es un lenguaje de programación creado en 1985 para
desarrollar sistemas expertos que provee un ambiente para construir
aplicaciones basadas en reglas, estas reglas se ejecutan cuando sus
condiciones o hechos se cumplen. Sus principales características son: facilidad
para representar el conocimiento, portabilidad entre diferentes arquitecturas y
sistemas operativos, capacidad de integrarse con otras aplicaciones,
herramientas para el desarrollo de aplicaciones, además que es un software de
dominio público.
Activación de metas
Este módulo activa las metas dada una situación, estas metas son las tareas
que el robot debe realizar.
Soluciones alambradas
Son un conjunto de circuitos o hardware que resuelvan problemas específicos.
Planeador
Un planeador se encarga de: dada una posición inicial de un robot A en un
espacio W y un camino τ especificando una secuencia continua de posiciones,
encontrar un camino libre de obstáculos. En caso de no existir dicho camino se
debe reportar que es imposible llegar a la posición final.
Planear se puede definir como un procedimiento o una guía para cumplir un
objetivo. Para esto, se requiere buscar sobre el espacio de configuraciones del
entorno un camino que corresponda a las operaciones que resolverán el
problema. Por ejemplo, en esta tesis se necesita que el robot se mueva de una
posición a otra para tomar unas fotografías. Esto se resolvió generando una
secuencia de puntos que cubra la región en la cual se desea crear el mundo
virtual.

9
Socket: es una interfaz que conecta una aplicación con un protocolo de red, así el
programador solo se debe preocupar por escribir y leer datos del socket dejando al sistema
operativo transportar el mensaje a través de la red.
10
Tcl/Tk: lenguaje de programación, entre sus características se encuentra la facilidad de
crear gráficos así como la capacidad de escribir extensiones en otros lenguajes.

11
Marco teórico

El control del robot consiste en varias capas. La primera de ellas es el

planeador que toma un estado inicial y uno final y una descripción del mundo,
para generar el plan global para llevar al robot al estado final. En el caso que
el comando sea mover al robot de un cuarto a otro, el planeador busca la mejor
secuencia de movimientos para llegar al destino final. Dentro de cada cuarto
busca el mejor camino para evadir los obstáculos basado en los obstáculos
conocidos.
En este caso se utilizó un planeador basado en campos potenciales descrito en
el apartado 3.2 .
Navegador
El navegador toma los datos del planeador y determina la mejor trayectoria,
que básicamente consiste en un conjunto de ángulos y distancias que el robot
necesita para alcanzar su destino. El problema se define como: dado un
conjunto de coordenadas P(x1, y1), P(x2, y2),..., P(xn, yn) y un tiempo t
obtenidos por el planeador encontrar los ángulos de rotación θi, las distancias
di y la velocidad vi para llegar a dichas coordenadas.
Piloto
El piloto es el encargado de ejecutar las trayectorias generadas por el
navegador. Básicamente, para cada paso i el robot se debe mover una distancia
di y girar un ángulo θi. Revisa obstáculos desconocidos para el planeador y
trata de evitarlos.
Controlador
Este módulo controla los motores del robot y lee los datos de los sensores.
Este módulo está implementado en el módulo ExecuteCommand que se
describe en el apartado 3.1.2.1.
Aprendizaje
Puede ser uno o varios módulos donde el sistema puede aprender a resolver
nuevos problemas utilizando algoritmos genéticos, métodos probabilísticas,
cadenas de Markov, etc.

2.1.4 El robot tx8

El tx8 es un robot de modelo B14 fabricado por Real World Interface, Inc.
[BeeSoft]; es un robot móvil cilíndrico equipado con una base con ruedas que
provee al robot dos ejes de movimiento: traslación (movimiento paralelo a la

12
Marco teórico

cabeza del robot) y rotación (movimiento perpendicular a la cabeza del robot).

También cuenta con controladores de movimiento para gobernar el
movimiento del robot, así como con odómetros.
El robot cuenta con tres tipos de sensores externos que le permiten recolectar
datos del ambiente en donde se encuentra y poder interactuar con el ambiente;
los sensores son: sonar, infrarrojo y tacto. Además cuenta con una
computadora en la cual se ejecutan los programas que controlan el robot.
Para controlar su movimiento y estimar su posición el robot cuenta con un
conjunto de odómetros. Dado que los odómetros se basan en un sistema de
coordenadas diferente a las coordenadas del laboratorio se debe realizar una
transformación del sistema de coordenadas11.
Para la programación del robot se utilizaron las bibliotecas proporcionadas por
el fabricante llamadas BeeSoft Scheduler las cuales organizan y ejecutan las
rutinas del programa, son las encargadas de ejecutar todos los módulos del
programa a intervalos de tiempo regulares. Esto nos da la opción de ejecutar
un gran número de tareas sin preocuparse con cuestiones del hardware del
robot o de los tiempos de ejecución. Para utilizar estas bibliotecas se utilizan
módulos, los cuales son funciones escritas en lenguaje C que se encargan de
controlar el robot. Los módulos pueden ser los encargados de sensar el
ambiente, cambiar las metas del robot con base a los datos sensados o mover
el robot para que alcance sus metas.
Al robot se le han hecho las siguientes modificaciones: se le colocó una laptop
con una red inalámbrica para poder controlar al robot de esta forma, así como
una cámara de video con el fin de poder tomar fotografías y video desde la
perspectiva del robot. La Figura 2 se presenta una fotografía del robot.

11
Para ver la transformación en detalle ver el apartado 2.4 .

13
Marco teórico

Figura 2 Fotografía del robot B14.

2.2 Lenguajes de programación

2.2.1 Introducción a los lenguajes de programación
La comunicación es una de las esencias de la computación y son los lenguajes
de programación los que permiten esta comunicación. Existen muchos tipos
de lenguajes utilizados por las computadoras, ya sea para comunicarse entre
dos computadoras, dos procesos o entre usuarios y computadoras.
Existen lenguajes especializados utilizados para la comunicación entre
computadoras y seres humanos, diseñados para los más diversos propósitos.
Estos leguajes son conocidos como lenguajes de programación. Un lenguaje
de programación es una notación con la que se puede transmitir algoritmos
tanto a computadoras como a otras personas. Debe soportar la definición
dinámica de las acciones, esto quiere decir que no sólo necesita especificar
operaciones básicas de la computadora, sino que además debe de permitirle al
usuario o programador especificar cómo ejecutar estos pasos para resolver un
problema en particular.

2.2.2 Sintaxis y semántica

Cuando se define un lenguaje es necesario realizar las especificaciones de éste
de una manera precisa. Para esto se debe de definir al lenguaje de dos
maneras: sintáctica y semánticamente [Terrence].

14
Marco teórico

• Sintaxis. Las reglas sintácticas definen las secuencias de caracteres que

pueden hacer un programa válido. Esta definición requiere especificar
los caracteres que pueden ser utilizados en programas válidos así como
las formas válidas en las que estos caracteres pueden expresarse juntos.
• Semántica. Las reglas semánticas definen el significado de cada uno de
los posibles programas permitidos por las reglas sintácticas. Especificar
la semántica es más complicado que especificar la sintaxis, ya que su
significado no es siempre obvio.

2.2.3 Características de un buen lenguaje de

programación
Las características que definen un buen lenguaje de programación son las
siguientes [Terrence]:
1. Claridad, sencillez y unidad. Un lenguaje debe de aportar un marco
conceptual para pensar los algoritmos y un medio de expresar esos
algoritmos, debe de convertirse en un ayudante al programador mucho
antes de la etapa de codificación. Además debe de proporcionar un
conjunto claro, sencillo y unificado de conceptos y instrucciones básicas
para el desarrollo de algoritmos, es deseable que tenga una sintaxis
simple que ayude a la escritura y corrección de los programas.
2. Ortogonalidad. Este atributo consiste en combinar características del
lenguaje de manera que éstas tengan un significado. Supóngase que un
lenguaje tenga expresiones capaces de producir valores enteros y tenga
la capacidad de evaluar expresiones como verdaderas o falsas. Estas
características son ortogonales si se puede usar cualquier expresión
entera dentro del enunciado condicional.
3. Naturalidad para la aplicación. Es la capacidad en la sintaxis que, al
usarse correctamente, permita que la estructura del programa refleje la
estructura lógica subyacente del algoritmo.
4. Apoyo para la abstracción. Es la facilidad que da el lenguaje para
expresar por medio de estructuras de datos los objetos necesarios para
crear el programa.
5. Facilidad para verificar los programas. Consiste en qué tan fácil se
pueden verificar los programas, ya sea por medio de métodos formales,

15
Marco teórico

leyendo el código o probando el programa por medio de datos de

entrada y verificando la salida.
6. Entorno de programación. Este aspecto se refiere a la disponibilidad
de herramientas que ayuden al desarrollo de las aplicaciones.
7. Portabilidad de los programas: Es la capacidad que tiene el lenguaje
de ejecutarse en diferentes arquitecturas sin hacerle modificaciones.
8. Costos de uso. Estos se dividen en:
a. Costos de ejecución del programa.
b. Costos de traducción del programa.
c. Costo de creación, pruebas y uso de programas.
d. Costo de mantenimiento de los programas.

2.2.4 Consideraciones en el diseño de lenguajes

Se puede construir una computadora utilizando dispositivos electrónicos, en
este caso se tendría una computadora real o de hardware, pero también es
posible construir una computadora por medio de software, un programa que se
ejecuta en una computadora real, a esto se le llama una computadora simulada
por software o virtual. Por esto una computadora es un conjunto de algoritmos
y estructuras de datos capaz de almacenar y ejecutar programas.
Un lenguaje de programación se hace construyendo un traductor el cual se
encarga de traducir el programa a lenguaje máquina que puede ser ejecutado
por alguna computadora, ya sea real o virtual [Watson].
Una computadora tiene los siguientes componentes:
1. Datos. Una computadora debe de suministrar diversas clases de datos.
2. Operaciones primitivas. Debe proporcionar un conjunto de
operaciones primitivas para la manipulación de datos.
3. Control de secuencias. Una computadora debe aportar mecanismos
para controlar el orden en el que se van a ejecutar las operaciones
primitivas.
4. Acceso a datos. Son mecanismos para controlar los datos que se
suministran a cada ejecución de una operación.

16
Marco teórico

5. Gestión de almacenamiento. Son mecanismos para controlar la

asignación de almacenamiento para programas y datos.
6. Entorno de operación. Una computadora debe suministrar
mecanismos para la comunicación con un entrono externo que contiene
programas y datos que se van a procesar.
Para construir un compilador para un nuevo lenguaje de programación, lo que
se debe de hacer es construir una máquina virtual que cumpla con estas
características y un traductor que traduzca los programas escritos en este
lenguaje a un código que pueda ser ejecutado por la máquina virtual. Esta
máquina virtual puede tener parte de su arquitectura directamente en una
computadora real.

2.2.5 Protocolos de red

Un protocolo es una convención de comunicación, un conjunto de acuerdos y
reglas con los que dos o más partes puedan interactuar para el intercambio de
información. Un protocolo también implica negociación. Para la
comunicación entre seres humanos los protocolos pueden ser bastante
informales, pero para la comunicación entre máquinas se necesita una
definición exacta y cuidadosa. Se debe especificar qué y cuándo es
comunicado. Los elementos de un protocolo son los siguientes:
• Sintaxis. La estructura de la información comunicada, incluyendo
códigos, formatos de datos y su representación en términos de niveles
de señales.
• Semántica. El significado de las señales intercambiadas, incluyendo
control de la información para la coordinación y manejo de errores.
• Tiempos. Cuando la señal va a poder ser transmitida o buscada por el
receptor, la secuencia de la información y otras cuestiones de
coordinación.
Dado que un protocolo sirve para comunicar a dos máquinas y un lenguaje de
programación sirve para la comunicación (y posterior traducción) entre los
hombres y las computadoras, y que tienen una sintaxis y una semántica,
ambos forman parte de un conjunto más amplio, el de los lenguajes
[Spragins].

17
Marco teórico

2.3 Ambientes virtuales

Un ambiente virtual es una interfaz que permite a los humanos visualizar e
interactuar con ambientes generados por medio de computadoras en tiempo
real, a través de los canales sensoriales humanos. La realidad virtual es una
herramienta que permite al usuario la inmersión en una experiencia rica en
sensaciones, usando sensores de entrada y de salida, creada por un motor de
realidad.
Los motores de realidad son los encargados de procesar las sensaciones de
entrada y generar nuevas sensaciones de salida. Por ejemplo, el usuario al oír
el crujir del fuego (sensación de salida), voltea la cabeza (acción del usuario),
y un dispositivo capta el movimiento (sensación de entrada) y genera la
imagen del fuego (el motor de realidad).
Un sistema de realidad virtual cuenta con los siguientes elementos:
• Efectores. Son los sensores tanto de entrada como de salida que permiten la
interacción entre el usuario y el motor de realidad.
• Motor de realidad. Es el sistema de computación y su hardware asociado
que le da a los efectores la información necesaria para interactuar.
• Aplicación. Es el software que define el contexto de la aplicación y las
leyes de interacción entre los objetos y los usuarios.
• Geometría. Es la información que describe los atributos de los objetos. Esta
información es procesada por la aplicación para crear el mundo virtual. En
un futuro esta parte evolucionará y no solamente almacenará las
características geométricas de los objetos sino también su textura, olor,
peso, etc.
Las principales razones para construir un ambiente virtual son:
• Lo real es muy caro para construir. Ejemplo: Sistema de entrenamiento
para una estación espacial.
• Lo real es muy peligroso para trabajar. Ejemplo: una planta nuclear.
• Lo real ya no existe. Ejemplo: reconstrucción de sitios arqueológicos.
• Lo real todavía no existe. Ejemplo: representación de diseños
arquitectónicos por construir.

18
Marco teórico

• Lo real es muy difícil de visualizar. Ejemplo: entrenadores para

cirugías.
• Mostrar lugares lejanos. Ejemplo: visitas virtuales a la torre Eiffel.
Puesto que en un ambiente virtual es necesario estimular los sentidos del
usuario, se necesitan interfaces que hagan interactuar al motor de realidad con
el usuario, las principales interfaces son:
• Interfaz visual
• Interfaz auditiva
• Interfaz táctil
• Interfaz de movimiento
Para la creación del mundo virtual es necesario modelarlo; existe una gran
variedad de instrumentos desarrollados con este fin. Los principales
instrumentos utilizados para la captura de objetos tridimensionales son:
• Escáneres láser de mano
• Escáneres láser de gran rango
• Captura de movimiento (Motion capture)
Las aplicaciones de realidad virtual más sobresalientes actualmente son:
• Simulador de cirugía oral. Este sistema incrementa significativamente la
aceptación del paciente al tratamiento además de ahorrar tiempo, ya que
la exploración inicial, la toma de datos y la planeación pueden ser
hechas en una sola cita.
• Exhibición virtual de un gorila en el zoológico de Atlanta.
• Vietnam virtual, para el tratamiento de pacientes con estrés
postraumático.
• Entrenamiento médico para campos de batalla.
• Entrenamiento para liberación de rehenes.
• Profesores virtuales.

19
Marco teórico

La principal diferencia entre la animación y la realidad virtual es que, en la

animación, las escenas son dibujadas previamente y después proyectadas en la
secuencia deseada, mientras que en la realidad virtual, son dibujadas en
tiempo real en relación con la posición y las acciones del usuario, por lo que el
usuario tiene absoluto control sobre lo que está viendo.
Las principales diferencias entre la realidad virtual y los sistemas CAD es que,
en la primera, se preocupa por lograr una realidad sensorial y permite al
usuario caminar, tocar y manipular objetos en el mundo, y los segundos se
preocupa por la exactitud en los modelos. En ambos se pueden modelar luces,
materiales y texturas; de hecho muchos paquetes de realidad virtual son
capaces de importar datos de sistemas CAD.
Un sistema de realidad virtual debe generar las imágenes en tiempo real a una
tasa mínima de 10 cuadros por segundo, siendo una tasa de alrededor de 30
cuadros por segundo deseable. Otro requerimiento es que la reacción debe de
ser antes de los siguientes 50 milisegundos de que se realizó la entrada para no
observar problemas en el desempeño.

2.3.1 La clasificación de Zeltzers de los ambientes

virtuales
Zeltzers propone tres conceptos para la clasificación de los ambientes de
realidad virtual, cada uno de estos conceptos está dentro de un eje de un cubo
donde el punto (0,0,0) son las aplicaciones más primitivas de realidad virtual y
en el punto (1,1,1) se sitúan las aplicaciones más avanzadas donde no se podrá
distinguir entre la realidad y el mundo virtual (ver Figura 3).
Las tres características propuestas por Zeltzers son:
• Presencia. Provee una medida de la fidelidad de los sensores de entrada
y de los canales de salida. Es la medida en la que el ambiente se sienta
real.
• Interacción. Se refiere al nivel de acceso de los parámetros o variables
de un objeto. Es la medida en la que el usuario pueda explorar
libremente el mundo virtual.
• Autonomía. Se refiere a la medida en la que los objetos virtuales
reaccionan a eventos y estímulos. Es la medida de la fidelidad con la
que reaccionan los objetos virtuales frente a los estímulos.

20
Marco teórico

Figura 3 Diagrama de Zeltzers.

2.3.2 Render por imágenes

En los últimos años se ha visto un incremento del uso de las fotografías
panorámicas para la creación de mundos virtuales [Chen]. Esta técnica tiene la
ventaja de que se están desplegando imágenes reales en lugar de imágenes
creadas. Estas fotografías son creadas por medio de un proceso fuera de línea
a partir de fotografías normales, deformándolas. Además la libertad de
navegación está limitada a girar en torno a un solo punto. En esta tesis se
propone un método para poder desplazarse en cualquier dirección utilizando
fotografías panorámicas.
Estas técnicas forman parte de un nuevo paradigma en el dibujo de gráficas
por computadora conocido como render por imágenes [Debevec] (image-
rendering). Este paradigma busca poder desplegar mundos
independientemente de su complejidad, facilitar su modelado, y además, al
estar utilizando imágenes reales, obtener una presencia visual muy alta.

21
Marco teórico

2.3.2.1 Fotografías panorámicas

Una foto panorámica o panorama es una fotografía inusualmente ancha, por lo
menos tan ancha como lo que el ojo humano es capaz de ver; se puede
observar lo que existe delante del espectador así como lo que existe detrás,
también existen panorámicas en las que se puede observar tanto lo que hay
arriba como lo que hay abajo. Estas imágenes han sido utilizadas en el cine
para crear un efecto de inmersión en la película. Actualmente estas imágenes
están siendo utilizadas para crear ambientes virtuales y paseos virtuales en
algunas páginas Web. Se pueden ver ejemplos de fotografías panorámicas en
[Dersch].
Las fotografías panorámicas comenzaron en el siglo XIX cuando se pintaban
escenas dentro de cuartos redondos. En 1843 se patentó la primer cámara para
tomar fotos panorámicas, y desde entonces este tipo de fotografía ha tenido un
gran desarrollo. Actualmente con las computadoras no es necesario comprar
equipo especial para hacer este tipo de fotografías. En su lugar se pueden
utilizar programas especiales para pegar las fotografías y crear fotos
panorámicas digitales, convirtiéndolas en parte de la tecnología multimedia y
de realidad virtual. Como se ve extraña una foto panorámica de 360 grados, se
pueden utilizar programas especiales que sólo muestran un sector del
panorama y se puede navegar por la foto utilizando el mouse.
Actualmente las fotografías son tomadas manualmente o con la ayuda de un
tripié y se tiene poco control sobre los ángulos con los que se tomaron las
fotos. Por esta razón es difícil crear las panorámicas automáticamente, ya que
es necesario establecer manualmente puntos de control y algunas veces es
necesario retocar el producto final. Esto hace que la creación de estas
fotografías sea un proceso tardado, caro y con la necesidad de utilizar personal
calificado. Lo que se intenta hacer es utilizar un robot para tener control sobre
la posición de las fotografías y así crear las fotografías de una manera
automática.
Puesto que en el proceso estándar para la creación de fotografías panorámicas
no se conocen exactamente los valores de muchos de los datos, se utilizan los
puntos de control entre las imágenes para estimar estos valores. Los puntos de
control son; puntos en el área común que tienen dos imágenes que son el
mismo objeto, como por ejemplo piedras pequeñas, esquinas de ventanas o
puertas. Se recomienda esparcirlas lo más posible por la región común a las
dos fotografías. El proceso de búsqueda y definición de los puntos de control

22
Marco teórico

es el que lleva más tiempo-hombre en la creación de una fotografía

panorámica.
Para la creación de las panorámicas se utilizan los procesos de deformado e
hilvanado. Estos procesos son las técnicas que utiliza una computadora para
combinar imágenes sin que parezca que la imagen final fue unida por una
computadora a partir de varias fotografías. Para esto es necesario corregir las
distorsiones de las fotografías, como la distorsión de barril, y alinearlas
utilizando análisis óptico de las fotografías12.
Existen tres tipos de fotografías panorámicas relacionados con el tipo de
figura dentro de la cual está el espectador: cilíndrica, cúbica y esférica. La
fotografía que da una mejor sensación de inmersión es la esférica, ya que el
interactor está metido dentro de una esfera y se pueden tener vistas de 360
grados horizontales y verticales, al contrario de las fotografías cilíndricas
donde solamente se puede tener desplazamientos horizontales. Las fotografías
cúbicas también tienen la capacidad de desplazamiento tanto vertical como
horizontal y son utilizadas junto con VRML13. En este trabajo se decidió
utilizar fotografías cilíndricas porque la cámara del robot no se puede
desplazar de manera vertical.
El gran problema de las fotografías panorámicas es el error de paralaje; este
error puede distorsionar la fotografía e incluso dejarla inservible. Este error se
debe a que los puntos nodales14 de la cámara cambian de posición a medida
que la cámara va rotando, por lo que es necesario que la cámara gire sobre
alguno de sus puntos nodales. Para evitar este error, es necesario colocar
cuidadosamente la cámara en el tripié, o en este caso, en el robot móvil.

12
Ver el apartado 2.3.2.2 para una descripción de la distorsión de barril.
13
VRML: Virtual Reality Modeling Language (Lenguaje para el modelado de realidad
virtual) es un lenguaje que se utiliza para definir ambientes en tercera dimensión, para ser
desplegados a través de navegadores de Internet.
14
Punto nodal: un rayo de luz que entra a una lente cruzando el punto nodal frontal deberá
emerger por el punto nodal trasero exactamente con el mismo ángulo relativo al eje de la
lente con el que entró a ella. Los puntos nodales de las lentes son los mismos que los puntos
principales, a menos que se estén utilizando en lugares inusuales como debajo del agua.
Punto principal: una lente simple debe tener dos puntos principales, que deben estar en
algún punto dentro de los elementos del lente. Actualmente la mayoría de las lentes tienen
muchos elementos, lo que causa que los puntos principales puedan estar en cualquier lado,
inclusive fuera de las lentes.

23
Marco teórico

Una forma fácil de entender lo que es el error paralaje, es poner el dedo índice
frente a la cara y cerrar un ojo y alinear el dedo con un objeto como una puerta
o una ventana y rotar la cabeza. Se verá que conforme se gira la cabeza, el
dedo pierde su la alineación; este es el problema de paralaje [Rigg].

2.3.2.2 Corrección gamma y distorsión de barril

2.3.2.2.1 Corrección gamma

En imágenes digitales se utiliza la corrección gamma, debido a la naturaleza
no lineal de los dispositivos tanto de captura como de despliegue. Esto quiere
decir que los datos RGB15 de la imagen no corresponden directamente a los
valores de luz. Por esta razón cuando se están manipulando las imágenes, es
necesario utilizar el proceso de corrección gamma inverso antes de proceder a
la manipulación.
Suponiendo que se tiene un cuadrado formado por verde (0, 255, 0) rodeado
por otro de color magenta (255, 0, 255) y se gira 5 grados, ver Figura 4. Si no
se emplea el factor gamma el valor de los píxeles interpolados es el siguiente:
0.5 * [(0,255,0 ) + (255,0,255)] = (122,122,122 )

Lo que se presenta en la imagen final como rayas negras entre los cuadros
verde y magenta. Pero si se aplica la corrección gamma con un valor de 2.5 se
obtiene lo siguiente:

{0.5 * [(0,255 2.5

) (
,0 + 255 2.5 ,0,255 2.5 )]} 0.4
= (193,193,193)

Que da un mucho mejor resultado. El factor gamma depende del dispositivo

que se esté utilizando, pero un valor de 2.5 presenta buen resultado para la
mayoría de los dispositivos [Dersch].

15
RBG: Red blue green (rojo azul verde), es un método para codificar imágenes por
computadora separando la imagen en tres canales de colores; rojo, azul y verde.

24
Marco teórico

Figura 4 En la imagen de la izquierda es una imagen rotada sin utilizar la corrección

gamma, nótese el borde más oscuro entre los dos cuadros. La imagen de la derecha si
se utiliza corrección gamma; nótese como el cambio es mucho más gradual.16

2.3.2.2.2 Distorsión de barril (barrel distortion)

La distorsión de barril aparece en una gran cantidad de lentes, especialmente
en lentes del tipo gran angular. El efecto se puede observar en los extremos de
las fotografías cuando las líneas rectas se doblan hacia fuera; por esta razón se
le conoce como distorsión de barril ya que hace parecer las líneas rectas como
curvas, similar a un barril. El efecto contrario en el cual las líneas rectas se
doblan hacia adentro se le conoce como distorsión “pincushion”.

Figura 5 En la figura de la izquierda se puede ver la distorsión de barril,

especialmente en la columna. La fotografía de la derecha muestra la fotografía ya
corregida.17

Este error se corrige moviendo cada píxel de una manera radial, con base en
una función polinomial de tercer orden cuyos coeficientes dependen de cada

16
Las imágenes fueron tomadas de http://www.fh-furtwangen.de/~dersch.
17
Las imágenes fueron tomadas de http://www.fh-furtwangen.de/~dersch.

25
Marco teórico

lente. Esta función relaciona la distancia de una píxel del centro de la imagen
origen rsrc a la imagen destino rdest:
(
rsrc = a * rdest
3
+ b * rdest
2
)
+ c * rdest + d * rdest

El parámetro d es el factor de escalamiento de la imagen, Utilizando d=1 y

a=b=c=0 se deja la imagen como está, pero si se utiliza otro valor de d, se
escala la imagen y los parámetros a, b y c la deforman. Si se utilizan valores
negativos, los puntos distantes se acercan al centro corrigiendo la distorsión de
barril mientras que valores positivos alejan a los puntos del centro corrigiendo
la distorsión “pincushion”. El parámetro a corrige los píxeles más alejados de
la imagen mientras que el valor b es más uniforme. Para no escalar la imagen
se debe escoger el valor de d tal que a+b+c+d=1 [Dersch]. En la Figura 5 se
puede observar el efecto de la distorsión de barril.

2.4 Transformaciones en dos dimensiones

Una transformación implica el cambio de un sistema de coordenadas a otro y
representan todos los puntos en este nuevo sistema de coordenadas [Vera].

2.4.1 Traslación
Esta transformación responde al desplazamiento en X – Y de un sistema de
coordenadas con respecto a otro. Su expresión matemática es:
x * = x + Tx
y * = y + Ty

y de manera matricial:
1 0 0
[x *
y *
]
1 = [x

y 1] 0 1 0

Tx Ty 1


2.4.2 Rotación
La transformación es una rotación sobre el origen del sistema de coordenadas
por el ángulo θ. Se considera un punto dado por las coordenadas P(x, y) y se le
gira un ángulo θ a la posición P*(x*, y*) como se ve en la Figura 6.

26
Marco teórico

Figura 6 Rotación.

Dado que necesitamos una convención para el giro de los ángulos, los ángulos
positivos serán los ángulos en sentido contrario a las manecillas del reloj y los
ángulos negativos serán en sentido de las manecillas del reloj.
La transformación a P* desde P se puede calcular utilizando trigonometría:
x = r cos(φ )
y = r sin(φ )

De la Figura 6 se puede sacar los parámetros r y φ:

x = r cos(φ + θ ) = r cos φ cos θ − r sin φ sin θ
y = r sin(φ + θ ) = r sin φ cos θ + r cos φ sin θ

Sustituyendo a “x” y “y” por sus respectivos valores:

x * = x cos θ − y sin θ
y * = x sin θ + y cos θ

y de manera matricial:
 cos θ sin θ 0
[x *
y *
]
1 = [x y 1]− sin θ cos θ 0
 0 0 1

2.4.3 Composición de transformadas

La mayoría de las transformaciones de coordenadas requieren de mas de una
transformación por lo cual se necesita aplicar tanto una traslación como una
rotación. Para lograr esto se multiplican las matrices en el orden deseado y

27
Marco teórico

luego se multiplica la matriz resultante por el punto a transformar. Se debe de

tener cuidado en qué transformación se debe realizar primero; para el caso
utilizado en la tesis se debe realizar primero la traslación y luego la rotación.
La transformación queda de la siguiente forma:
 1 0 0
T (Tx , Ty ) =  0 1 0
 
Tx Ty 1
 
 cos θ sin θ 0
R(θ ) = − sin θ cos θ 0
 0 0 1
 cos θ sin θ 0
RT (Tx , Ty , θ ) = − sin θ
 
cos θ 0
 Tx Ty 1


Regresando la fórmula a su forma escalar:

 cos θ sin θ 0
[x *
y *
]
1 = [x

y 1]− sin θ cos θ 0

 Tx Ty 1

x * = x cos θ − y sin θ + Tx
y * = x sin θ + y cos θ + Ty

28
Desarrollo

3 Desarrollo
3.1 El lenguaje ROBEL
El lenguaje ROBEL (RObot BEhaivor Language) fue diseñado con la
finalidad de tener una plataforma que permita utilizar algoritmos en diferentes
tipos de robots móviles, sin importar sus diferencias en arquitectura o
construcción. Es la base para la arquitectura ViRBot.
Este lenguaje consta de los comandos necesarios para el control de las
operaciones básicas de los robots móviles, lo que ayuda al lenguaje a ser una
herramienta efectiva para el desarrollo de aplicaciones sobre robots móviles.
Otra ventaja del lenguaje es la facilidad que presenta para la enseñanza y la
investigación; dado que uno de los robots con los que se trabaja es un robot
virtual [Hernández, Vázquez], se pueden desarrollar y probar algoritmos sin
necesidad de utilizar un robot real, teniendo la ventaja que se puede tener un
robot por desarrollador, lo que es un ahorro en costo y se protege al robot real
de daños por posibles colisiones durante la etapa de desarrollo del algoritmo.
Existen dos maneras para darle comandos a un robot por medio de ROBEL: la
primera utilizando scripts18 que se encuentran dentro del disco duro del robot
o se cargan por el puerto serial y la segunda es por medio de comandos dados
directamente sobre un socket de comunicación abierto para este fin. Con esta
última forma se puede comunicar el robot con otros procesos ya sea en la
misma máquina o en alguna máquina remota, lo que abre la posibilidad de
utilizar programas desarrollados en otros lenguajes e incluso corriendo dichos
programas en otras máquinas para calcular los algoritmos de movimiento del
robot. Esta característica le da una flexibilidad muy poderosa a ROBEL, ya
que se pueden ejecutar algoritmos complejos en robots que cuentan con un
procesador pequeño, además que permite utilizar algoritmos en otros
lenguajes sin tener que migrarlos para que se puedan ejecutar en un robot
especifico, así como desarrollar algoritmos en el lenguaje que se desee,
utilizando ROBEL como interfaz.
Dado que se puede utilizar el lenguaje ROBEL tanto para escribir programas
como para comunicarse con otros programas, se puede decir que el lenguaje

18
Script: conjunto de instrucciones que pueden ser ejecutadas sin la intervención del
usuario.

29
Desarrollo

ROBEL tiene una dualidad como lenguaje de programación y como protocolo

de comunicación.

3.1.1 Descripción del lenguaje

Para utilizar el lenguaje se utiliza un programa que se llama robottx8 el cual se
describe a continuación.

3.1.1.1 Instrucciones del lenguaje19

En la Tabla 3-1 se describen las instrucciones de ROBEL.
Comando Respuesta Descripción
Mueve al robot un
Mv <distancia> Mv <distancia real> ángulo y una distancia
<ángulo> <tiempo> <ángulo real> <colisión> dada. Permite mover el
@{id} @{id} robot en coordenadas
polares
Mueve el robot a la
Mvto <x> <y> <tiempo> Mvto <x real> <y real> posición (x, y). Permite
@{id} <colisión> @{id} mover al robot en
coordenadas cartesianas.
Left <distancia real>
Mueve al robot 90° a la
Left @{id} <ángulo real> <colisión>
derecha
@{id}
Right <distancia real>
Mueve al robot 90° a la
Right @{id} <ángulo real> <colisión>
izquierda
@{id}
Forward <distancia real>
Mueve al robot 1 dm
Forward @{id} <ángulo real> <colisión>
hacia adelante.
@{id}
Backward <distancia
Mueve al robot 1 dm
Backward @{id} real> <ángulo>
hacia atrás.
<colisión> @{id}

19
Para ver los diferentes sockets del programa ver el Apéndice A.

30
Desarrollo

Loads [nombre script] Carga el script dado en

Loads <éxito> @{id}
@{id} la memoria del robot.
Script [nombre script]
Script <éxito> @{id} Ejecuta el script dado.
@{id}
Muestra el contenido del
sensor dado por tipo de
Shs [tipo de sensor] sensor y número.
Shs <valor> @{id}
<número> @{id} Regresa valor tanto al
socket de respuesta
como al de sensores.
Introduce nuevas
Ic <x> <y> <ángulo>
Ic @{id} coordenadas (x, y,
@{id}
ángulo) al robot.
Regresa las coordenadas
Sc <x> <y> <ángulo>
Sc @{id} en las que se encuentra
@{id}
el robot.
Hace una comparación
con el último sensor
If ({comparador}
leído y realiza el salto a
<valor>) goto [etiqueta]
la etiqueta si se cumple
con la condición.
Regresa al socket de
sensores las coordenadas
Ras @{id} Ras @{id}
y el valor de todos los
sensores del robot.
Manda al socket de fotos
el comando [Nombre del
Tap @{id} Tap @{id}
laboratorio]-[fecha]-X-
Y-Angulo.20
Tabla 3-1 Instrucciones del lenguaje ROBEL

20
Este comando fue diseñado para tomar fotos desde el robot utilizando un proceso que en
el socket de fotos.

31
Desarrollo

NOTA: Los valores expresados entre signos mayor que y menor que < >,
son valores de punto flotante; los expresados entre corchetes [ ] son valores
tipo cadena; los expresados entre llaves { } son de tipo entero y los valores
que puede tomar {comparador} son =, < ó >.
Las distancias están dadas en decímetros y los ángulos en
radianes.
La cadena @<id> sirve como identificador de la instrucción.
Además de estas funciones, se pueden agregar funciones de usuario
desarrolladas en C, con lo que se puede extender el lenguaje para que se
adapte a necesidades más específicas.
Se puede manipular el valor de los sockets así como otras características por
medio de archivos de configuración u opciones de configuración dadas en la
línea de comandos21.

3.1.2 Construcción del lenguaje

Para la construcción del lenguaje se tuvieron que construir dos máquinas
virtuales para comunicar los comandos ROBEL con la arquitectura del robot.
La primer máquina virtual se llama ExecuteCommand, que se encarga de las
operaciones más sencillas del robot; es la encargada de comunicarse con el
robot, independientemente de su arquitectura. La segunda se llama
ReadCommand, que es la encargada de la lectura, traducción de los comandos
y la comunicación en el módulo ExecuteCommand.
Además, se definió una interfaz para cada una de las máquinas virtuales, con
lo que se logra una construcción modular con el fin de poder cambiar
cualquiera de las dos máquinas virtuales sin tener que hacer cambios a la otra.

3.1.2.1 Descripción de la máquina virtual ExecuteCommand

La máquina virtual ExecuteCommand es la encargada de comunicarse
directamente con la arquitectura del robot y controlar las operaciones a bajo
nivel, como son el control del desplazamiento o lectura de los sensores y
cuenta con los siguientes registros:

21
Ver el Apéndice A para una descripción de las opciones de configuración del programa.

32
Desarrollo

• Distance (Distancia). Por medio de este registro se le comunica al robot

la distancia en decímetros que se deberá mover.
• Angle (Ángulo). Se utiliza este registro para comunicar el giro en
radianes que el robot se deberá mover.
• Traslating (Trasladando). Este registro vale cero si el robot no se está
desplazando y uno si el robot se está desplazando.
• Rotating (Rotando). Este registro vale cero si el robot no está girando y
uno en caso contrario.
• Executing (Ejecutando). Vale uno si los registros Rotating o Traslating
valen uno y cero si ambos valen cero.
• Colition (Colisión). Vale uno si se detecta una colisión.
• Robot: Este registro es una estructura donde se guardan datos sobre el
robot como su posición (x, y, ángulo), la cantidad, el valor y la posición
de los sensores, así como el número y características de los motores de
los robots.
• ValueSensor (ValorSensor). Tiene el valor del último sensor leído.
• OldX, OldY, OldAngle (AntiguaX, AntiguaY, AntiguoÁngulo). Son el
registro temporal de posición; sirve para hacer cálculos sobre el
desplazamiento del robot.
Además de estos acumuladores, se tienen las siguientes operaciones para el
manejo de los datos:
• vmROBEL_move_robot (mueve_robot). Mueve el robot en
coordenadas cilíndricas.
• vmROBEL_move_to (mueve_a). Mueve el robot en coordenadas
cartesianas.
• vmROBEL_readSensorByName (lee_sensor_por_nombre). Lee el valor
de un sensor y lo pone en el registro ValueSensor.
• vmROBEL_IntroducePosition (IntroducePosición). Recibe como
parámetros (x, y, ángulo), los tres como valores flotantes de doble
precisión. Esta operación introduce una nueva posición; ésta es la única

33
Desarrollo

manera correcta de cambiar el registro Robot.Position para que se

actualice automáticamente.
• vmROBEL_UpdateRobotPosition (ActualizaPosición). Esta operación
actualiza la posición del robot después de un movimiento.
• vmROBEL_keepRobotCoordinates (GuardaCoordenadas). Guarda el
valor de las coordenadas dadas en el registro temporal de posición.
• vmROBEL_getRobotCoordinates (ObténCoordenadas). Recupera los
valores de las coordenadas guardadas en el registro temporal de
posición.
Por último tiene los siguientes mecanismos internos de control:
• ModuleExecuteCommand (MóduloEjecutaComando). Éste es un
mecanismo que verifica los valores de los registros Angle y Distance, y
si son diferentes de cero traslada o rota el robot; además es el encargado
de poner los registros en cero después de dar la orden de movimiento.
Controla que el robot no gire y se traslade al mismo tiempo.
• Service (Servicio). Este mecanismo actualiza los registros después de
que se terminó una traslación o una rotación. Apaga el programa en
caso que se reciba una señal de bajo voltaje.
• SonarCallback (RegresoSonar). Actualiza el valor de los sonares en la
estructura de datos Robot.
• IrCallback (RegresoInfrarrojo). Actualiza el valor de los sensores
infrarrojos en la estructura de datos Robot.
• ContactCallback (RegresoContacto). Actualiza el valor de los sensores
de contacto en la estructura de datos Robot.

3.1.2.2 Descripción de la máquina virtual ReadCommand

La máquina virtual ReadCommand es la encargada de traducir las
instrucciones ROBEL y darle los comandos correspondientes a la máquina
virtual ExecuteCommand y contiene los siguientes registros:

34
Desarrollo

• A. Éste es el acumulador donde se guardan los datos provenientes del

parser22.
• Message (Mensaje): Guarda la instrucción que se está ejecutando.
• OldMessage (AntiguoMensaje): Guarda la instrucción que se acaba de
procesar, este registro se utiliza para poder distinguir cuándo un nuevo
comando ha llegado.
• PresentScript (ScriptActual). Guarda el script que se encuentra en
ejecución.
• ScriptStackData (PilaDatosScripts). Una pila para las estructuras de
script para permitir que la recursividad en los scripts.
• ScriptInst (InstanciasScripts). Es un acumulador para guardar los scripts
cargados.
• Commands (Comandos). Es el socket de comandos.
• Acknolage (Respuesta). Es el socket de respuesta.
Tiene las siguientes operaciones:
• ROBEL_validate (valida). Pasa por el parser la instrucción y guarda los
datos en el registro A.
• ROBEL_execute (ejecuta). Ejecuta el comando después de procesarlo
con ROBEL_validate.
• ROBEL_execute_script (ejecuta_script). Ejecuta un script.
• ROBEL_if_command (commando_condicional). Permite ejecutar
expresiones condicionales dentro de los scripts.
Para la fácil manipulación de estas máquinas virtuales se definió un API23 en
C el cual se explica en el Apéndice B.

22
Parser: programa encargado de hacer el análisis semántico de un archivo fuente.
23
API: application program interface (Interfaz para la programación de aplicaciones) es un
conjunto de rutinas, protocolos y herramientas utilizadas para construir programas.

35
Desarrollo

3.1.3 Análisis del lenguaje

En esta sección se analizarán los elementos del lenguaje con los criterios
expuestos en el punto 2.2.3 .
1. Claridad, sencillez y unidad. Dado que el programa sólo realiza unos
cuantos comandos, y éstos están relacionados directamente con la forma
en la que se mueve el robot o con lecturas de sus sensores, el
programador tiene una herramienta fácil y práctica para hacer los
movimientos que se necesitan en los algoritmos de navegación. Por otro
lado, el lenguaje carece de flexibilidad para crear estructuras
condicionales o ciclos, lo que dificulta la codificación de algoritmos
directamente en el lenguaje. Esto se ve compensado con la posibilidad
de definir funciones de usuario en lenguaje C o utilizando el leguaje
como protocolo de comunicación entre el robot y otros programas. De
todas formas es recomendable extender el lenguaje para hacer ciclos,
condicionales, llamadas a función y manejo de tipos.
2. Ortogonalidad. El lenguaje no presenta características de
Ortogonalidad, lo que es deseable ya que se reduce la posibilidad que
los programas tengan errores lógicos.
3. Naturalidad para la aplicación. Dada la gran cantidad de diferentes
aproximaciones para resolver los problemas de los robots móviles, es
imposible que el lenguaje tenga una naturalidad para la aplicación; esto
se ve suplido por la capacidad que tiene de comunicarse con otros
programas escritos en otro lenguaje donde se pueda expresar correcta y
fácilmente el algoritmo que se está desarrollando.
4. Apoyo para la abstracción. El lenguaje presenta facilidad para
manipular datos referentes al robot, como por ejemplo los sensores de
los robots, pero no para representar los distintos tipos de objetos que se
presentan en el exterior del robot; esto es una ventaja ya que permite al
usuario realizar la representación del mundo que más le convenga a su
algoritmo.
5. Facilidad para la verificación de programas. Dado que el conjunto de
instrucciones es pequeño y bien diferenciado, es fácil la verificación de
los programas; además, se cuenta con una versión del lenguaje que
corre sobre un robot virtual, por lo que se pueden verificar fácilmente
los programas que se escriban sin necesidad de poner en riesgo de
colisión al robot real.

36
Desarrollo

6. Entorno de programación. El programa presenta un buen entorno de

programación dado por una aplicación de robots virtuales, donde se
pueden validar y desarrollar los algoritmos. Es deseable agregarle
funciones para depurar los scripts.
7. Portabilidad de programas: Los programas son totalmente portables
ya que se ejecutan dentro de una máquina virtual. Actualmente se
pueden ejecutar en dos tipos de robots reales y en un sistema de robots
virtuales.
8. Costo de uso:
a. Costo de ejecución de los programas. El costo de ejecución no es
importante ya que la mayor parte del tiempo el programa está
esperando que el robot termine de ejecutar los comandos de
desplazamiento.
b. Costo de traducción de los programas. Ya que el lenguaje se
traduce completamente en tiempo de ejecución, se podría impedir
una rápida respuesta del programa, pero depende del procesador
con el que cuente el robot móvil.
c. Costo de creación, prueba y uso de programas. Este costo se
debe analizar desde dos perspectivas. La primera es con scripts
escritos directamente desde el lenguaje ROBEL donde el costo es
bajo dada la facilidad del lenguaje. La segunda es cuando el
lenguaje se utiliza como protocolo de comunicación entre el robot
y algún otro programa, en este caso el costo está relacionado más
con el costo del lenguaje de desarrollando del algoritmo.
d. Costo de mantenimiento de los programas. Al igual que el punto
anterior, este costo se debe analizar desde dos perspectivas:
cuando los programas están escritos directamente en el lenguaje
ROBEL, y cuando el lenguaje es utilizado como protocolo de
comunicación. Para determinar estos costos es necesario utilizar
el lenguaje durante más tiempo, pero se puede suponer que el
costo será bajo.

3.2 Campos potenciales

El método que se utilizó para planear el movimiento del robot fue el de los
campos potenciales. En este método el robot es modelado como una partícula
bajo la influencia de un campo potencial artificial U en el cual las variaciones

37
Desarrollo

del campo son un reflejo de la estructura del área de trabajo. La función de

potencial es definida generalmente como la suma de las fuerzas de atracción
que empujan el robot a la posición final, y las fuerzas de repulsión que
empujan al robot lejos de las áreas prohibidas, que en este caso están
representadas por los obstáculos. Con esta técnica, la planeación del
movimiento se hace de una manera recursiva; en cada iteración se calcula la
fuerza inducida por el campo potencial en la posición donde se encuentra el
robot y con esta fuerza se calcula la dirección del próximo movimiento.
Este método fue diseñado originalmente para evadir obstáculos en tiempo real,
en ambientes donde no se tenía un conocimiento previo del mundo. Esta
aproximación hace que el robot pueda atorarse en mínimos locales. Para
evitarlo, los campos potenciales están siendo utilizados en robots que tienen
alguna idea de su entorno y se utilizan diversas técnicas para salir o evitar los
mínimos locales.
Un mínimo local es un punto en el espacio donde las fuerzas de atracción y las
fuerzas de repulsión se equilibran, dando como resultado que la fuerza total es
cero, causando que el robot empieza a oscilar alrededor del mismo punto. En
la Figura 7 se puede observar cómo la fuerza atractiva guía al robot a la
concavidad. En cierto punto qloc la fuerza de repulsión generada por el
obstáculo cancela la fuerza de atracción generada por la meta. Esta
configuración estable donde la fuerza es igual a cero es un mínimo local de la
función potencial total.

Figura 7 Mínimo local24.

24
Figura tomada de [Latombe].

38
Desarrollo

3.2.1 Cálculo del campo potencial

Existen múltiples aproximaciones a los campos potenciales, la utilizada en
este trabajo se describe a continuación.
El campo potencial está dado por:
r r
F (q ) = −∇U (q )
r
donde ∇U (q ) denota el vector gradiente de U y q=(x,y) representa la posición
del robot. Para el caso de dos dimensiones esta dado por:
r  ∂U ∂x 
∇U =  
 ∂U ∂y 

Para que el robot sea atraído hacia el punto de destino y repelido por los
obstáculos, U debe de ser construida como la suma de dos funciones más
elementales:
U (q ) = U att (q ) + U rep (q ) (3.2.1)

donde Uatt es la función de atracción a la posición final y Urep es la fuerza de

repulsión dada por los obstáculos.
La fuerza de atracción está dada por:
r r
Fatt (q ) = −∇U att (q ) (3.2.2)

La fuerza de repulsión está dada por:

r r
Frep (q ) = −∇U rep (q ) (3.2.3)

Dadas las fórmulas anteriores y que la fuerza de repulsión es igual a la suma

de las fuerzas generadas por cada uno de los obstáculos, se puede deducir que
la fuerza total sobre el robot está dada por la siguiente formula:
r r N r
Ftotal (q ) = Fatt (q ) − ∑ Frep
i
(q )
i =0

donde N es el número de obstáculos conocidos dentro del área de trabajo.

El cálculo de las funciones de atracción y de repulsión es todavía un problema
abierto en el que no se ha encontrado una función óptima que funcione para
cualquier área de trabajo.

39
Desarrollo

En la Figura 8 se muestra el campo atractivo (Figura 8b), el campo repulsivo

(Figura 8c) y la suma de los dos (Figura 8d) para una configuración (Figura
8a). Se muestran las superficies equipotenciales del campo total (Figura 8e)
así como el camino generado siguiendo el gradiente negativo. La Figura 8f
muestra una matriz del vector gradiente sobre un espacio.

Figura 8 Muestra de un campo potencial para un espacio dado25.

La Uatt que se utilizó en este caso está dada por la siguiente fórmula:
 1 ε q − qdest 2
si q − q dest ≤ d 0
U att (q ) =  2 1
 ε 2 q − qdest si q − qdest > d 0

donde qdest es el punto al que se quiere llegar.

25
Figura tomada de [Latombe].

40
Desarrollo

Aplicando la ecuación (3.2.2) a la expresión anterior, obtenemos la fuerza de

atracción:
 − ε 1 (q − qdest ) si q − qdest ≤ d 0
r 
Fatt (q ) = 
−ε2
(q − qdest ) si q − qdest > d 0
(3.3.4)
 q − qdest


La Urep utilizada está dado por la siguiente fórmula:

  1 1
 12η  −  si q − qobs ≤ d1
U rep (q ) =   q − qobs d1 
 0 si q − qobs > d1


donde qobs es el punto más cercano del objeto a la posición del robot, η es una
constante de proporcionalidad y d1 es la distancia máxima de influencia de la
fuerza de repulsión.
Aplicando la ecuación (3.2.3) a la expresión anterior, obtenemos la fuerza de
repulsión:
  1 1 1 (q − qobs )
r − η  −  si q − q obs ≤ d1
Frep (q ) =   q − q obs d1  q − q obs 2
q − q obs (3.3.5)
 0 si q − q obs > d1


Puesto que la fuerza total puede ser muy alta, se corre el riesgo que la
aceleración o la distancia que recorra el robot sea demasiado grande por lo que
para calcular la posición siguiente se normaliza y se escala por un valor dado.
Esto se expresa de la siguiente manera:
qt +1 = qt + δf (q ) (3.3.6)

donde δ es la distancia que deberá moverse el robot y f(q) es la fuerza

normalizada que se calcula de la siguiente forma:
r
F (q )
f (q ) = r
F (q )

Dado que los campos potenciales tienen el problema que el robot pueda caer
en un mínimo local, y que para este caso en particular se tiene un
conocimiento aproximado del área de trabajo, se emplean técnicas de
inteligencia artificial para encontrar la salida del mínimo local. El método que
se aplicó es el de colocar destinos temporales cerca de las esquinas del o los

41
Desarrollo

objetos que están generando el mínimo local. Estos destinos temporales se

vuelven fuerzas de atracción temporales, las cuales eventualmente sacarán al
robot del mínimo local ayudándolo a llegar a su destino.

3.2.2 Instrumentación
Ya que la navegación del robot se realiza dentro de un espacio conocido, se
tiene la posibilidad de utilizar un mapa del lugar para facilitar el cálculo de las
trayectorias. Por esta razón se decidió utilizar CLIPS26, ya que al definir los
objetos en el mundo y el estado del robot como hechos, se puede fácilmente
crear reglas para calcular las fuerzas de atracción y de repulsión, con lo que se
facilita la escritura del programa. Además se logra integrar la descripción del
mundo con el módulo de representación del conocimiento.
Tener el lenguaje ROBEL en el robot B14 facilitó la realización del algoritmo,
ya que se utilizó la capacidad de recibir comandos por medio de sockets
ahorrando el problema de crear una interfaz específica entre las bibliotecas
para el manejo del robot B14 y CLIPS, evitando un trabajo extra. Otra ventaja
de esta aproximación es la posibilidad de correr el programa de campos
potenciales en una máquina remota he incluso hacer los cálculos fuera de
línea.
El programa utiliza una representación simbólica del área de navegación27, y
utiliza esta representación para encontrar tanto las fuerzas de atracción como
las de repulsión. En esta representación cada obstáculo está representado
como un polígono, que consiste en una lista ordenada de los vértices en el
sentido de las manecillas de reloj. Además están definidas áreas prohibidas
cerca de cada polígono; estas áreas son lugares donde el robot no tiene
permitido entrar. Su existencia se debe a que en el desarrollo de los campos
potenciales, se modela al robot como un punto sin dimensiones, y se
ensanchan todos los polígonos una distancia igual a la que debe guardar el
centro del robot y los obstáculos para considerar las dimensiones del robot
[Tomás]. En la Figura 9 se muestra el área de navegación robot; las franjas
alrededor de los objetos representan las zonas prohibidas.

26
Ver el apartado 2.1.3 sección representación del conocimiento.
27
Ver el Apéndice C para una explicación de la representación simbólica.

42
Desarrollo

Figura 9 Representación simbólica del Laboratorio de Interfaces Inteligentes.

Teniendo la representación gráfica, se dieron al programa que calcula los

campos potenciales una serie de puntos que cubrieran cierta parte del
laboratorio; estos puntos marcan el recorrido que se debe de seguir para tomar
las fotos, Figura 10. La estrategia que se siguió para establecer los puntos fue
la de trazar dos líneas paralelas cercanas a los objetos conocidos, y sobre las
líneas poner los puntos cada 20 cm; con el fin de asegurar una distancia entre
fotos menor que la dada por la Tabla 3-2.

Figura 10 Ejemplo de los puntos con lo que se traza el camino a seguir por el robot.

Con los puntos obtenidos se utilizó el programa de los campos potenciales

para calcular la ruta entre ellos. Dada la ruta que cubría cierta parte del
laboratorio, se utilizó un programa escrito en ROBEL28 para tomar un
conjunto de fotos en cada punto calculado por el programa de campos

28
Ver el Apéndice D para ver el script.

43
Desarrollo

potenciales (ver Figura 11). De esta forma se asegura tener una buena
cobertura a lo largo de todo el laboratorio.

Figura 11 Ruta trazada por el planeador y ejecutada por el robot B14 para tomar las
fotos.

En la Figura 12 se muestran los puntos donde se tomaron las fotos para la

creación de las fotografías panorámicas utilizadas en el mundo virtual.

Figura 12 Puntos donde se tomaron las fotos.

3.3 El ambiente virtual creado

3.3.1 Definición del mundo virtual
El objetivo del ambiente virtual es simular la navegación del robot B14 en el
Laboratorio de Interfaces Inteligentes utilizando fotografías, con el fin de
lograr realismo en el ambiente sin tener que recurrir a procesos complejos de
modelado. El usuario se deberá sentir como si estuviera manejando el robot de

44
Desarrollo

una manera remota con la posibilidad de hacerlo girar o avanzar utilizando el

mouse.
El método que se utilizó para la realización del ambiente virtual es una tomar
colección de fotografías. Con estas crear las fotografías panorámicas
ordenadas por su posición X – Y; estas fotografías serán manipuladas en
tiempo real para simular la navegación en el mundo virtual.
La metodología para tomar las fotografías utilizando el robot móvil fue tomar
un conjunto de fotografías en el mismo punto, girando al robot y etiquetando
cada fotografía con la posición X – Y – Ángulo, en puntos esparcidos en todo
la zona de interés.

3.3.1.1 Otros mundos virtuales creados con fotografías

Entre los sistemas de dibujo de gráficas por computadora basados en
fotografías destaca el desarrollado por la Universidad de Carolina del Norte.
Este sistema utiliza una cámara para tomar las fotografías panorámicas y un
sensor láser para obtener los valores de profundidad para cada uno de los
píxeles dentro de la imagen, con los datos del escáner láser y las fotografías se
generan pequeñas unidades de información (tile) las cuales contienen la
ubicación tridimensional del píxel y su color. Posteriormente se utilizan los
tiles para generar las imágenes. Para sus experimentos utilizaron una
computadora Silicon Graphics Onyx2 con InfiniteReality2 logrando 12.14
cuadros por segundo. El método tiene la desventaja que se necesita equipo
sumamente costoso para la adquisición de las imágenes (35,000 dólares según
los autores) además de computadoras especializadas para poder desplegar el
mundo creado [McAllister].
Los otros métodos de render basados en imágenes utilizan puntos de control
sobre dos o más fotografías, y estas fotos se procesan para generar las
fotografías intermedias. Este método tiene la desventaja que es necesario
encontrar manualmente los puntos de control, lo cual sería impráctico para
crear mundos virtuales por la gran cantidad de puntos que se necesitarían
definir [Seitz].
Un método que pretende incrementar el grado de inmersión utilizando las
fotografías panorámicas es el Omnistereo, el cual consiste en crear dos
fotografías panorámicas, una para cada ojo, con la finalidad de dar la
sensación de profundidad. Dado que las fotografía deben ser tomadas en los
puntos nodales de la cámara, lo que hicieron en el proyecto fue generar las

45
Desarrollo

imágenes panorámicas utilizando el lado derecho para la fotografía que

corresponde al ojo izquierdo y viceversa [Peleg].
Estos métodos tienen el inconveniente que al estar utilizando imágenes como
datos para la creación de mundos virtuales, necesitan que todo el mundo esté
estático incluyendo el Sol, por lo que estos métodos no se pueden utilizar para
mundos muy grandes en espacios abiertos..

3.3.2 Herramientas utilizadas

Para la creación de las fotografías panorámicas se eligió el programa
Panorama Tools29. Este es un programa especializado en la creación de
fotografías panorámicas, el cual se eligió por las siguientes razones: es un
programa en el que se puede trabajar con Linux, es el único completamente
gratuito y se puede automatizar el proceso de creación de panorámicas
mediante programas hechos en bash30 u otro intérprete de comandos. Es un
programa que pone especial énfasis en la manipulación matemática de la
imagen, a fin de preservar la calidad de las imágenes durante el proceso de
manipulación, teniendo una calidad superior a los otros programas. Por otro
lado, este programa cuenta con características para mejorar la calidad de la
imagen, como son la posibilidad de realizar corrección de color en las
imágenes antes de crear la fotografía panorámica, corregir la distorsión de
barril y realizar corrección gamma31. Además, la posibilidad de controlar
Panorama Tools por medio de scripts facilitó la tarea de automatizar la
creación de las fotografías panorámicas.
Dado que se busca hacer un ambiente virtual para páginas Web, el lenguaje
con el que se hizo el programa que se encarga del despliegue fue Java. Este
lenguaje además de ser multiplataforma, lo que quiere decir que el mismo
código objeto se puede ejecutar en varias arquitecturas y sistemas operativos,
es un lenguaje simple, robusto, seguro y con soporte de multitarea.

29
El programa se puede obtener en la dirección de Internet: http://www.fh-
furtwangen.de/~dersch.
30
Bash: interprete de comandos muy utilizado en sistemas UNIX, entre sus ventajas cuenta
con tener todas las características de un lenguaje de programación.
31
Ver el apartado 2.3.2.2 para una descripción de estas distorsiones.

46
Desarrollo

3.3.3 Creación de las fotografías panorámicas

Con la ayuda del robot móvil se tomaron una gran cantidad de fotografías,
cada una de ellas etiquetadas tanto por posición como por ángulo; esto ayudó
a tener un control de qué fotografías debían estar en cada imagen panorámica,
además de su posición dentro de la imagen. Para poder crear automáticamente
las fotografías panorámicas, fue necesario calcular los valores de la distorsión
de barril32 y el ángulo horizontal de visión de la cámara. Para esto se tomaron
todas las fotos de una posición y se marcaron una gran cantidad de puntos de
control, para poder ser utilizados por el programa optimizador y utilizar estos
valores como un esqueleto para la creación de todas las fotografías.
Los puntos importantes para la creación automática de las fotografías
panorámicas son el control del ángulo con el cual se tomaron las fotos y una
cuidadosa caracterización de la lente.
En la Figura 14 se muestran dos fotografías tomadas por el robot y la Figura
13 la fotografía panorámica creada.

Figura 13 Fotografía panorámica creada.

32
Ver el apartado 2.3.2.2 para una descripción de la distorsión de barril.

47
Desarrollo

Figura 14 Fotografías tomada a 1.78555 y 2.72439 radianes respectivamente.

3.3.4 Desarrollo del programa de despliegue

El programa organiza las fotos dentro de una estructura que llamaremos grafo,
en la cual cada nodo es una fotografía y los lazos unen fotografías que están
dentro de la distancia de influencia33 de la foto. Esto permite manejar mundos
con un gran número de fotos, pero solamente utilizar para los cálculos las
fotos más cercanas al lugar donde se está creando la imagen final.
El proceso para crear la imagen es el siguiente: primero se busca la fotografía
más cercana al punto de proyección y se convierte en la fotografía actual. Se
crea un nuevo hilo34 el cual lee y obtiene los píxeles de todas las fotografías
que están dentro de su zona de influencia de la nueva fotografía actual. Por
último, si el punto de proyección que se desea está dentro de la zona de

33
Se llamará distancia de influencia a la distancia máxima a la cual se puede alejar del
lugar donde fue tomada la foto panorámica y aun se pueden obtener proyecciones validas
de ella.
34
Hilo: expresión que viene de la palabra inglesa thread; significa una parte del programa
que se puede ejecutar independientemente de otros programas.

48
Desarrollo

influencia de alguna fotografía y además no se encuentra dentro de algún

obstáculo del mundo, entonces se procede a crear la nueva imagen. El
programa utiliza la misma representación simbólica que la utilizada para el
cálculo de los campos potenciales35.
El programa cuenta con las siguientes clases:
• Vertex (Vértice). Es una clase abstracta que representa los nodos del
grafo utilizado
• Tree (Árbol). Es una clase que hace las funciones básicas de los grafos.
• Photo (Foto). Es una clase que extiende a Vertex. Guarda la
información referente a la posición de la fotografía panorámica dentro
del mundo, así como los lazos que la relacionan con las otras instancias
de Photo que están dentro de su zona de influencia, y guarda un registro
de los obstáculos que se encuentran en su zona de influencia. También
guarda la información y los métodos relacionados con la foto
panorámica. Lanza un hilo para la creación de la imagen a desplegar.
• PhotoContainer (DepositoFoto). Clase que extiende a Tree. Es la
encargada de calcular la fotografía actual y ver si el punto de
proyección que se quiere utilizar es un punto válido, así como controlar
el modelo lógico del ambiente y la navegación en éste. Es la encargada
de controlar el hilo que controla la transferencia de las fotos entre el
servidor y el navegador de Web.
• Parser. Clase que implementa el parser utilizado para construir el
modelo lógico del mundo virtual.
• VRPanorama. Es el applet principal, controla las instancias de las otras
clases así como contiene una clase que despacha los eventos.

3.3.4.1 Proyección de las imágenes

Para el despliegue del mundo virtual es necesario construir las imágenes que
se van a desplegar a partir de las fotografías panorámicas, por lo que es
necesario manipularlas. Para lograrlo es necesario calcular la proyección de
las imágenes panorámicas en un punto diferente al punto central sobre el cual

35
Ver el Apéndice C para una descripción de la definición del mundo.

49
Desarrollo

fueron tomadas las fotos. A continuación se describe el algoritmo desarrollado

para lograr la proyección.
Se supone que las fotografías panorámicas tienen una altura de imHeight y un
ancho de imWidth, y que la imagen que se quiere crear tiene una altura
panHeight y un ancho panWidth.
Como se utilizaron fotografías panorámicas del tipo cilíndrico, se les puede
considerar como cilindros de radio R cuyo centro es el punto donde se
tomaron las fotografías PTF (punto de toma de foto). Entonces el problema se
reduce a encontrar la manera en que se proyectaría el cilindro dado en algún
otro punto de proyección PP (punto de proyección). (Ver Figura 15).

Figura 15 Representación geométrica de los cálculos utilizados para la proyección de

la imagen final.

La transformación de la imagen se hace en dos dimensiones por lo que se debe

calcular una relación horizontal y una vertical.
Un dato que es importante calcular es en qué coordenadas del cilindro se
encuentra el punto PT (punto de transformación) que se está transformando.
La distancia PP-PT se llamará e. Para el cálculo se traza una línea que pase
por PP con un ángulo θ (ecuación 3.3.1) y se calculan las intersecciones de la
recta con la proyección azimutal del círculo (ecuación 3.3.2). Para efectos de
cálculo se considerará que el punto PTF está situado en el origen, el punto PP

50
Desarrollo

en (x1, y1) y el punto PT en (xt, yt), pero se pueden utilizar traslaciones36 para
realizar los cálculos en puntos fuera del origen.
y = m( x − x1 ) + y1 (3.3.1)

x2 + y2 = R2 (3.3.2)
donde:
m = tan (θ )

Sustituyendo (3.3.1) en (3.3.2) se tiene:

x 2 + {m( x − x1 ) + y1 } = R 2
2

Reagrupando x:
( ) { }
x 2 1 + m 2 + x(2m{y1 − mx1 }) + ( y1 − mx1 ) − R 2 = 0
2

Lo que es una ecuación de segundo grado para x, cuya solución es:

ax 2 + bx + c = 0
− b ± b 2 − 4ac (3.3.3)
x=
2a

Donde los factores a, b y c son los siguientes:

a = 1 + m2
b = 2m{y1 − mx1 } (3.3.4)
c = ( y1 − mx1 ) − R 2
2

Para encontrar xt se sustituye y evalúan los valores dados en (3.3.4) en (3.3.3)

y yt sustituyendo el valor xt encontrado en (3.3.1)
Este cálculo da los dos puntos de intersección entre la recta y el círculo, uno
para el valor de θ y el otro para -θ. Para saber qué valor se debe tomar se
efectúa la siguiente regla: se utiliza el valor positivo de la raíz cuando θ esté
en el rango [-π/2, π/2]; en caso contrario se emplea la raíz negativa.
Se supone que la cámara con la cual se está simulando el mundo virtual tiene
un campo de visión vertical dado por vfov; además el número de píxeles que

36
Ver el apartado 2.4 para las ecuaciones que definen las traslaciones.

51
Desarrollo

se utilizarán en la fotografía panorámica es igual a panHeight cuando la

distancia es igual a R, es decir, que el punto PP es igual al punto PTF. Dado
que el ángulo vfov permanece constante, se puede calcular la cantidad de
píxeles de la fotografía panorámica que se van a utilizar en la imagen final
transv cuando el punto de proyección se encuentre a una distancia e con la
siguiente relación:
e
transv = panHeight (3.3.5)
R

Esta relación da la transformación de los píxeles verticales de la fotografía,

indica si se deben expandir o comprimir los píxeles de la fotografía
panorámica en la imagen a crear. De la expresión se deduce que dependiendo
de la distancia e, se pueden utilizar mayor o menor número de píxeles de la
fotografía panorámica. Puesto que la imagen crece simétricamente para arriba
como para abajo, el valor inicial vi y el valor final vf para de los píxeles de la
fotografía panorámica están dados por.
height − transv
vi =
2
(3.3.6)
height + transv
vf = vi + transv =
2

Y el incremento entre píxel y píxel de la imagen final con relación a la

fotografía panorámica tv está dado por:
transv
tv = (3.3.7)
panHeight

Para calcular la relación horizontal y dado que la fotografía panorámica tiene

un ángulo de visión horizontal de 1 vuelta se emplea este ángulo ϕ para
calcular el píxel en la imagen original utilizando la siguiente expresión:
ϕ *Width
transh = (3.3.8)
2π

donde el ángulo ϕ se calcula utilizando la formula:

y 
ϕ = a tan t 
 xt 

Los valores transv y transh son valores reales mientras que los píxeles son
valores enteros, así que se redondea el valor obtenido al entero más próximo y

52
Desarrollo

ese es el píxel que se utiliza. Esta técnica es el método más simple de

interpolación, pero aun así su desempeño es aceptable, además de que se
ahorra la realización de muchas operaciones en cada imagen; esto es muy
importante ya que se necesitan crear las imágenes en tiempo real [Pitas].
El cálculo del radio del cilindro donde están proyectadas las fotos
panorámicas se hizo bajo los siguientes supuestos. Dado que el cilindro es un
cuerpo de proyección en las fotos y no un objeto dentro del mundo, se debe
encontrar un estimado de un radio. Además, dado que en la misma fotografía
los puntos están distribuidos a diferentes profundidades, no existe un valor
correcto que represente a todos los puntos de la foto. Por esta razón se tomó
como radio la mitad del ancho o del largo del cuarto de trabajo, el Laboratorio
de Interfaces mide aproximadamente 6 m por 6 m, así que el radio que se
utilizó fue de 3 m.
Como ya se dijo, cada fotografía tiene una zona de influencia dentro de la cual
es posible la creación de las imágenes; cuyo tamaño esta relacionada con las
expresiones utilizadas para su manipulación.
Este criterio de influencia tiene que ver con la distancia máxima y mínima a la
que se puede estar de la circunferencia que describe la fotografía panorámica;
es obvio pensar que el área de influencia es una circunferencia de radio ri,
además que la distancia máxima a la que se puede estar de la circunferencia
emax que representa la fotografía panorámica, es cuando se está parado en el
borde de la zona de influencia mirando al centro de la circunferencia, y que la
distancia mínima emin es estando parado en el mismo punto pero mirando hacia
el lado contrario:
emax = R + ri
(3.3.9)
emin = R − ri

Uno de los criterios que debe de cumplir es que los píxeles que necesitamos
para la creación de las columnas de la imagen no estén fuera de la fotografía
panorámica; esto sucede cuando el valor inicial de la interpolación vertical es
menor que cero:
vi < 0

Sustituyendo esta expresión en (3.3.6) se tiene:

Height < transv

53
Desarrollo

Sustituyendo en (3.3.5) se obtiene la distancia máxima emax a la que se puede

obtener una imagen:
Height * R
emax =
panHeight

Sustituyendo la ecuación en (3.3.9) se obtiene el primer criterio para

determinar el radio de la zona de influencia ri (vi):
 Height 
ri (vi ) <  − 1 R (3.3.10)
 panHeight 

Otro criterio que se debe de cumplir dado que se utilizan procesos de

interpolación de baja calidad, es que la diferencia entre la relación horizontal ó
vertical de dos píxeles adyacentes de la imagen final esté entre 0.5 y 2, con
esto se asegura no saltarse más de un píxel entre cada interpolación ni usar el
mismo píxel más de dos veces.
Se analizará primero el caso del desplazamiento vertical. La distancia entre
cada píxel del desplazamiento vertical se calcula dividiendo transv entre
panHeight:
transv e
tv = =
panHeight R

Para emax la relación no puede ser mayor que 2:

emax R + ri
2> =
R R

Despejando se obtiene el segundo criterio para la zona de influencia ri(tv)1:

R > ri (tv )1 (3.3.11)

Para emin la relación no puede ser menor que 0.5:

emin R − ri
0.5 < =
R R

Despejando se obtiene el tercer criterio para la zona de influencia ri(tv)2:

R > 2ri (tv )2 (3.3.12)

Puesto que la inecuación (3.3.11) tiene como resultado un valor mayor de ri

que el de la inecuación (3.3.12), el valor ri(tv)1 no será tomado en cuenta.

54
Desarrollo

Ahora se analizará el caso de la interpolación horizontal. Se tiene que el valor

del píxel para un ángulo ϕ dado está dado por la ecuación (3.3.8), así el valor
entre un píxel y el que le sigue es igual a:
th = transhi − transhi −1
ϕ iWidth ϕ i −1Width
th − (3.3.13)
2π 2π
Width
th = (ϕ i − ϕ i−1 )
2π

Para calcular la relación ϕi - ϕi-1, se utilizan las fórmulas que relacionan el

ángulo con el arco recorrido:
ds = Rdϕ
ds = edθ

Igualando estas dos relaciones:

Rdθ = edϕ

Integrando y despejando ϕ:
θ ⋅e
ϕ=
R

Sustituyendo esta ecuación en (3.3.13):

Width ⋅ e
(θ i − θ i−1 )
2πR

El valor θi - θi-1 es igual al ángulo horizontal de visión hvof entre el ancho de

la panorámica panWidth, sustituyendo en la expresión anterior:
Width ⋅ e  hfov 
 
2πR  panWidth 

Para emax la relación no puede ser mayor que 2:

Width ⋅ emax  hfov  Width ⋅ (R + ri )  hfov 
  =   < 2
2πR  panWidth  2πR  panWidth 

Despejando se obtiene el cuarto criterio para la zona de influencia ri(th)1:

 4π ⋅ panWidth 
ri (th )1 <  − 1 R (3.3.14)
 hfov ⋅ Width 

55
Desarrollo

Para emin la relación no puede ser menor que 0.5:

Width ⋅ emin  hfov  Width ⋅ (R − ri )  hfov 
  =   > 0.5
2πR  panWidth  2πR  panWidth 

Despejando se obtiene el quinto criterio para la zona de influencia ri(th)2:

 πpanWidth 
ri (th )2 < 1 −  R (3.3.15)
 hfov ⋅ Width 

Dados estos cinco criterios el radio de la zona de influencia se calcula con el

menor de estos valores:
ri = min (ri (vi ), ri (tv ), ri (th )1 , ri (th )2 ) (3.3.16)

En la Tabla 3-2 se muestran los datos utilizados en el mundo creado, así como
el valor de ri:
Da tos Re sulta dos
R 30 ri(vi) 10
Height 320 ri(tv) 15
W idth 2000 ri(th)1 39.12
panHeight 240 ri(th)2 12.72
panW idth 320
hfov 0.87266463

ri= min(ri(vi),ri(tv),ri(th)1,ri(th)2= 10

Tabla 3-2 Cálculo del rango de influencia ri, para las fotografías panorámicas
utilizadas en el mundo creado.

3.3.5 Proceso de creación del mundo

Como ya se dijo nuestro objetivo es crear un mundo virtual automáticamente;
a continuación se presentan los pasos que se siguieron en el proyecto:
• Modelado de los obstáculos del mundo y creación de los puntos
destino de navegación: esta información es generada completamente
por los usuarios del sistema; esta fase no tiene ningún grado de
automatización. Consiste en generar los polígonos para el programa de
campos potenciales y el de desplegado de las imágenes finales del
mundo. Para esto se mide manualmente el cuarto que se va a utilizar.
También se determinan los puntos entre los cuales se va mover el robot
para tomar las fotos.

56
Desarrollo

• Creación de las rutas a seguir: en esta etapa se utiliza el mundo

modelado y los puntos determinados en la etapa anterior para generar
utilizando campos potenciales los scripts en ROBEL que dan los puntos
donde se deben de tomar las fotos.
• Toma de fotos: se ejecutan en el robot los scripts en ROBEL obtenidos
en el punto anterior y se toman todas las fotos necesarias para la
creación de las fotografías panorámicas.
• Caracterización de la cámara: una vez tomadas las fotos, se
determinan puntos de control y se utiliza el programa optimizador de
Panorama Tools para calcular los valores para corregir la distorsión de
barril37. En esta etapa la determinación de los puntos de control la
realiza el usuario.
• Creación de las fotografías panorámicas: dado que las fotos están
nombradas con el siguiente formato <Cuarto>_<Posición en
X>_<Posición en Y>_<Ángulo>, su utilizan estos datos para la creación
de dos scripts; el primero guarda los datos para la creación de cada
fotografía panorámica utilizando Panorama Tools y el segundo controla
la ejecución del paquete de proceso que crea la fotografía panorámica.
Teniendo estos script se realiza un proceso fuera de línea para crear
todas las fotografías panorámicas. También en esta etapa se crean las
directivas para cargar las fotografías en el programa que despliega las
fotos en el mundo virtual creado.
• Desplegado de la imagen: se utilizan las fotografías panorámicas para
desplegar las imágenes en una página Web siguiendo la técnica descrita
en el apartado 3.3.4.1.

37
Ver el apartado 2.3.2.2 para una descripción de la distorsión de barril.

57
Desarrollo

La Figura 16 es un esquema que explica el proceso de creación del mundo

virtual:

Figura 16 Esquema de los pasos a seguir para la creación del mundo virtual.

58
Conclusiones y resultados

4 Conclusiones y resultados
4.1 Propuestas para el mejoramiento de ROBEL
Después de utilizar el lenguaje ROBEL se hacen las siguientes propuestas con
el fin de expandir sus características como plataforma para el desarrollo de
algoritmos para robots móviles:
1. Agregar la posibilidad de creación de ciclos y sentencias condicionales
para tener la posibilidad de crear algoritmos más elaborados utilizando
ROBEL.
2. Crear un compilador que traduzca los scripts escritos en ROBEL a
lenguaje C, utilizando el API de ROBEL. Con esto se podrán
desarrollar los algoritmos utilizando ROBEL y posteriormente
agregarlos como funciones de usuario para ejecutarlos con mayor
rapidez y no tener que cargar el script cada vez que se ejecute el
programa.
3. Agregar características para la depuración de los scripts, como ver y
modificar el valor de las variables.
4. Agregar un entorno gráfico donde se puedan construir scripts en
ROBEL arrastrando, cortando y pegando bloques, para tener un entorno
de programación visual.
En la Figura 17 se presenta una gráfica de los diferentes módulos que
compondrían el sistema completo de desarrollo propuesto.
Esta estructura está pensada para obtener la facilidad de desarrollar en un
lenguaje específico para el robot como es ROBEL y la potencia y rapidez del
lenguaje C, además de poder utilizar el mismo algoritmo para varios robots.
El entorno gráfico se propone para tener una plataforma de desarrollo que
pueda competir con la plataforma creada por la compañía Lego con su
producto Mindstorm.

59
Conclusiones y resultados

Figura 17 Diagrama de la estructura de desarrollo para el lenguaje ROBEL.

4.2 Conclusiones sobre el mundo virtual

Se desarrollo un método para la creación de fotografías panorámicas,
prácticamente sin la intervención humana. Con esto se logró facilitar la
creación de este tipo de visitas virtuales. En la Figura 18 se muestra una
fotografía panorámica utilizada en el mundo virtual.

Figura 18 Fotografía panorámica creada para el mundo virtual.

60
Conclusiones y resultados

Utilizando el método descrito en esta tesis se tiene una manera fácil de crear
ambientes virtuales, sin tener que emplear demasiado tiempo modelando el
mundo. Este tipo de mundos virtuales puede ser utilizado para crear visitas a
museos o zonas arqueológicas, ya que al utilizar este método se estarían
mostrando fotos de las obras de interés en lugar de modelos de ellas.
El sistema tiene una muy buena calidad en las imágenes creadas. Este se
puede ver en la Figura 19, en la que se muestra una imagen obtenida por el
sistema a partir de una fotografía panorámica en el punto (–3, –3, –1.8)
situando a la foto en el origen.

Figura 19 Imagen creada por el sistema.

Con el sistema se obtuvo una tasa de refresco de entre 10 y 15 cuadros por

segundo en un procesador Celeron a 500 MHz con 64 Mbytes de RAM,
dependiendo de lo ocupado que se encuentre el sistema. Esto es un buen
desempeño considerando que el sistema se ejecuta dentro de un navegador y
corre en cualquier arquitectura y sistema operativo donde se tenga la
posibilidad de correr Java 2. Además, corre completamente en la máquina del
cliente por lo que el servidor no debe de instalar ningún software extra además
del servidor Web.
El sistema de desplegado de imágenes presenta el problema que se observan
saltos a la hora de cambiar de una foto a la otra. Esto se debe principalmente a
la dificultad de calcular el radio del cilindro donde está proyectada cada
fotografía panorámica, ya que no existe un valor correcto para este radio. Otra
causa de este problema es el error de paralaje entre una foto y la otra; además,
las fotografías no fueron tomadas exactamente en el lugar donde lo indican los
sensores de posición, esto debido a los errores intrínsecos a los sensores de

61
Conclusiones y resultados

traslación del robot. La manera como se corrigió esto fue disminuyendo el

radio de influencia ri al 30% del valor teórico, lo que implicó elevar la
densidad con la que las fotografías fueron tomadas. Esta elevación de
densidad trajo dos problemas menores que el anterior: incremento del tiempo
de captura de las imágenes, y que los archivos que crean el mundo virtual se
hicieron demasiado grandes.
Para la corrección del problema, la mejor solución sería cambiar el método de
creación de la imagen final por alguno que interpole entre dos o más imágenes
utilizando puntos de control, como el descrito por Seitz. Para esto es necesario
utilizar algoritmos de reconocimiento de patrones, para encontrar los puntos
de control necesarios en este tipo de algoritmos.
Por otro lado, el algoritmo de navegación de campos potenciales resultó ser
una aproximación muy efectiva. Esto es porque debido a una mayor magnitud
de las fuerzas de repulsión en las zonas cercanas a los obstáculos, la densidad
de fotografías es mayor cerca de los objetos, ayudando así a la disminución de
los problemas de paralaje.
El principal problema que se presentó fue a la hora de tomar las fotografías, ya
que al no tener un buen transmisor de video y al tener la tarjeta digitalizadora
de video en una PC, se utilizó un cable para la comunicación entre estos dos
componentes, lo que presentó un problema para el libre movimiento del robot.
Por otro lado, también se tuvieron problemas con la autonomía del robot, ya
que por la duración de las pilas de este no fue posible tomar fotografías de
grandes zonas sin tener que interrumpir el proceso para recargar las pilas.

62
Configuración del programa robottx8

Apéndice A Configuración del programa robottx8

El programa cuenta con cuatro sockets para comunicarse con otros procesos.
El primer socket es el de instrucciones; por medio de este el robot recibe los
comandos que va a ejecutar. El segundo es el de respuesta; éste es utilizado
para dar la respuesta a los comandos. El tercero es el socket de sensores; sirve
para recibir los datos de los sensores tanto de las instrucciones ras y shs. El
cuarto y último es el de fotografías, que sirve para comunicarse con el
programa encargado de controlar la cámara del robot.
Existe un archivo en el cual se configuran ciertos aspectos del
comportamiento del programa robottx8 como son los sockets para
comunicarse con el robot, la posición inicial del robot y otras características
del programa. El nombre del archivo es “.robottx8”. Este archivo tiene la
finalidad de poder personalizar el programa de una manera fácil sin la
necesidad de recompilar el programa. Las opciones se describen poniendo el
nombre de la característica seguida del signo igual y después el valor.
Las características son las siguientes:
• INITX (XINIC). La posición en X del robot al iniciar el programa.
• INITY (YINIC). La posición en Y del robot al iniciar el programa.
• INITANGLE (ANGULOINIC). El ángulo del robot al iniciar el
programa. La posición inicial del robot está dada por (INITX, INITY,
INITANGLE)
• HOSTNAME (MAQUINA). Es el nombre de la máquina donde está el
socket de respuesta. Si no se especifica el programa pregunta por él.
• OUTPORT (PUERTOSALIDA). Es el puerto del socket de respuesta
el cual está dado por HOSTNAME:OUTPORT. Si no se especifica el
programa pregunta por él.
• INPORT (PUERTOENTRADA). Es el puerto del socket de comandos.
Si no se especifica el programa pregunta por él.
• PICHOSTNAME (MAQUINAFOTOS). Es el nombre de la máquina
donde se encuentra el socket de fotografía.
• PICPORT (PUERTOFOTOS). Es el puerto de la máquina donde se
encuentra el socket de fotografía. El socket de fotografía está dado por

63
Configuración del programa robottx8

PICHOSTNAME:PICPORT. Si no se especifica, o la creación del

socket falla se utiliza el socket de respuesta de comandos.
• SENHOSTNAME (MAQUINASENSOR). Es el nombre de la
máquina donde se encuentra el socket de sensores ras y shs.
• SENPORT (PUERTOSENSOR). Es el puerto de la máquina donde se
encuentra el socket de sensores. El socket de sensores está dado por
SENHOSTNAME:SENPORT. Si no se especifica, o la creación del
socket falla se utiliza el socket de respuesta de comandos.
• TURNOFF (APAGADO). Sus valores son 0 ó 1. Si es 1, el programa
terminará cuando se reciba una señal de batería baja. El valor por
omisión es 0.
• VERBOSE (REDUNDANCIA). Sus valores son 0 ó 1. Si es 1, se
despliegan varios mensajes de advertencia. El valor por omisión es 0.
• DEBUG (DEPURADO). Sus valores son 0 ó 1. Si es 1, permite
ejecutar paso a paso las instrucciones de los scripts. El valor por
omisión es 0.
NOTA. El valor de los puertos debe ser mayor que 1024, ya que los puertos
inferiores están reservados por el sistema operativo para programas del
sistema.
A continuación se muestra un ejemplo del archivo de configuración (el
carácter # indica línea de comentario):

# La posición inicial del robot.

INITX=20
INITY=60
INITANGLE=0

# La dirección del socket de respuesta.

HOSTNAME=mezcal
OUTPORT=2005

# El puerto del socket de comandos.

INPORT=2001

# La dirección del socket de fotografías.

PICHOSTNAME=mezcal
PICPORT=2050

64
Configuración del programa robottx8

# La dirección del socket de sensores.

SENHOSTNAME=mezcal
SENPORT=4000

# Si es 1 apaga termina el programa cuando el voltaje del robot es muy bajo.

TURNOFF=0

# Imprime mensajes de información extra.

VERBOSE=1

# Permite la ejecución de scripts paso a paso.

DEBUG=0

Se le pueden dar además los valores a través de la línea de comandos al

momento de invocar al programa; éstas son las opciones.
-f <file> Cambia el archivo del que se van a leer las especificaciones.
-r <hostname> Cambia la opción HOSTNAME.
-o <numero> Cambia la opción OUTPORT.
-i <numero> Cambia la opción INPORT.
-n No pregunta por los datos que faltan.
-p <hostname> Cambia la opción PICHOSTNAME.
-c <numero> Cambia la opción PICPORT.
-s <hostname> Cambia la opción SENHOSTNAME.
-t <numero> Cambia la opción SENPORT.
-x <numero> Cambia la opción INITX.
-y <numero> Cambia la opción INITY.
-a <numero> Cambia la opción INITANGLE.
-h –help Despliega esta ayuda.
-V –version Imprime la versión del programa.

El comportamiento del programa para leer los parámetros es el que sigue:

1. Primero se leen las opciones dadas en la línea de comandos, si las hay.
2. Después se leen las opciones dadas por el archivo dado por el comando
–f, si lo hay.
3. Se lee y procesa el archivo .robottx8.
4. Si no se dio la bandera –n se preguntan por los datos que faltan.
5. En caso que falte alguno de los siguientes datos: HOSTNAME,
INPORT o OUTPORT, el programa termina.
Existe otro archivo de configuración el cual se usa para que el programa sepa
dónde buscar los scripts. El nombre del archivo es “.path”. El programa

65
Configuración del programa robottx8

funciona de la siguiente manera: se trata de encontrar el script dentro del

directorio en el que está corriendo el programa; si no lo encuentra lee la
primera línea del archivo y busca el script en esa ruta; si no lo encuentra lee el
segundo y así sucesivamente hasta encontrar el script o llegar al final del
archivo; en caso de no encontrar el script, se regresa el mensaje de error.

66
Interfaz de las máquinas virtuales

Apéndice B Interfaz de las máquinas virtuales

/* Este archivo de cabecera sirve para la creación de funciones de usuario y para
tener comunicación con los comandos internos de ROBEL. Su intención es
estandarizar la construcción de las maquinas virtuales de ROBEL */
#ifndef __ROBELAPI_H__
#define __ROBELAPI_H__
#include "robot.h"
/*------------------------------------------------------
Comandos en el módulo de ExecuteCommand.
--------------------------------------------------------*/
/*Mueve el robot un ángulo y una distancia dada en el tiempo dado.*/
void vmROBEL_move_robot(double distancia, double angulo, double tiempo);
/*Mueve al robot en línea recta al punto (x, y) en un tiempo dado.*/
void vmROBEL_move_to(double x, double y ,double tiempo);
/*Cambia el sistema coordenado del robot al punto (x, y, ángulo)*/
int vmROBEL_introduce_position(double x, double y, double angulo);
/*Lee en sensor dado por nombre[numSensor] nombre puede ser contact, infrared o
sonar.
Si el sensor no existe regresa –1.*/
int vmROBEL_readSensorByName(char *name, int numSensor);
/*Regresa el valor del último sensor leido por la función
vmROBEL_readSensorByName.*/
int vmROBEL_getValueSensor(void);
/*Regresa la rotación del sistema coordenado del robot.*/
double vmROBEL_getWorldAngle(void);
/*Guarda los coordenadas para calculos futuros.*/
int vmROBEL_keepCoordinates(double X, double Y, double angulo);
/*Obtiene las coordenadas guardadas por vmROBEL_keepCoordinates.*/
int vmROBEL_getCoordinates(double *X, double *Y, double *angulo);
/*
NOTA: Las dos funciones anteriores actúan como un acumulador, no como una pila.
*/
/*Regresa el valor de la bandera Executing.*/
int vmROBEL_isExecuting(void);
/*Regresa el valor de la bandera Colition y la pone en 0.*/
int vmROBEL_isColition(void);
/*Imprime el mensaje de error a stderr y sale del programa.*/
void vmROBEL_ERROR(char *Message,...);
/*Imprime el mensaje de error a stderr si la bandera de Verbose esta prendida.*/
void vmROBEL_WARNING(char *Message,...);
/*Imprime el mensaje a stdout si la bandera de Verbose esta prendida.*/
void vmROBEL_INFO(char *fmt,...);

67
Interfaz de las máquinas virtuales

/*--------------------------------------------------
Comandos en el módulo de ReadCommand.
-----------------------------------------------------*/
/*Valida la cadena s como un comando válido y pone los valores correspondientes
en el registro A; para tener acceso a este registro debe incluir al archivo parser.h */
int ROBEL_validates(char *s);
/*Ejecuta el comando con los datos que están en el registro A.*/
int ROBEL_execute(void);
/*Regresa el comando que se esta ejecutando.*/
char *ROBEL_getMessage(void);
/*Carga el script en la pila de script, si ya ha sido cargado, lo actualiza.*/
int ROBEL_load_script(char *script);
/*Regresa un apuntador al script que se esta ejecutando y NULL si no hay ningún
script en ejecución.*/
ScriptInst* ROBEL_getPresentScript(void);
/*Ejecuta el script, si el script no ha sido cargado lo carga; soporta llamadas
recursivas a los scripts.*/
int ROBEL_execute_script(char *name);
/*Realiza el salto condicional; modifica la ejecución del script si la condición es
satisfecha.*/
void ROBEL_if_command(ScriptInst *Script);
#endif

68
Descripción de la representación simbólica del mundo

Apéndice C Descripción de la representación simbólica

del mundo
Este archivo tiene una sintaxis basada en el lenguaje CLIPS; con esto se tiene
una traducción directa en hechos dentro de este lenguaje; por otro lado, la
creación de parsers en lenguajes procedurales, como en este caso Java, es muy
sencilla por lo que no causa problema tener una sintaxis basada en CLIPS.
A continuación se describen tanto la función como la sintaxis de los
principales atributos del mundo virtual.
• Límites del mundo virtual: define el cuadrado dentro del cual está
definido el mundo.
( limit_area <cuarto> <x1> <y1> <x2> <y2> <x3> <y3> <x4> <y4> )

• Puntos de referencia: marca puntos que son utilizados como puntos de

referencia para la navegación del robot móvil.
( reference_point <x> <y> )

• Polígono: representa un objeto dentro del mundo, define áreas dentro de

las cuales no está permitida la navegación. Son objetos definidos por
sus vértices en el sentido de las manecillas del reloj.
( polygon <tipo de polígono> <cuarto> <nombre del polígono> <x1> <y1> ... <xn>
<yn> )

• Fotografía: indica una fotografía panorámica, tanto el nombre de la foto

como su posición.
( photo <nombre de la foto> <x> <y> )

• Puerta: define el punto por donde se puede pasar de un cuarto a otro.

( door <cuarto 1> <cuarto 2> <x> <y> )

A continuación se muestra un ejemplo de la representación simbólica del

mundo.
;Representación simbólica del Laboratorio de Interfaces Inteligentes.

(limit_area LII 0.00 0.00 0.00 77.00 74.50 77.00 74.50 0.00)
(door LII nowhere 6.42 -.6)
(reference-point LII 10.0 10.0)
(reference-point LII 60.0 10.0)
(reference-point LII 20.0 50.0)
(reference-point LII 60.0 50.0)
(polygon object LII mesa1 1.50 22.90 1.50 30.50 32.00 30.50 32.00 22.90)
(polygon object LII mesa2 1.50 31.50 1.50 61.40 8.90 61.40 8.90 31.50)

69
Descripción de la representación simbólica del mundo

(polygon object LII mesa3 6.40 68.20 6.40 75.50 36.40 75.50 36.40 68.20)
(polygon object LII mesa4 42.00 68.20 42.00 75.50 73.00 75.50 73.00 68.20)
(polygon object LII mesa5 65.40 31.20 65.40 61.60 73.00 61.60 73.00 31.20)
(polygon object LII mesa6 42.70 22.90 42.70 30.50 73.00 30.50 73.00 22.90)
(polygon object LII mesa7 36.50 45.50 36.50 74.30 42.50 74.30 42.50 45.50)
(polygon object LII est1 6.40 67.50 1.50 67.50 1.50 75.00 6.40 75.00)
(polygon object LII est2 65.40 66.30 73.00 66.30 73.00 61.60 65.40 61.60)
(polygon door LII 65.40 1.50 65.40 3.20 74.50 3.20 74.50 1.50)

(polygon wall LII pared1 0.00 0.00 0.00 1.50 74.50 1.50 74.50 0.00)
(polygon wall LII pared2 0.00 0.00 0.00 77.00 1.50 77.00 1.50 0.00)
(polygon wall LII pared3 0.00 75.50 0.00 77.00 74.50 77.00 74.50 75.50)
(polygon wall LII pared4 74.50 9.00 73.00 9.00 73.00 77.00 74.50 77.00)

La salida gráfica que se obtiene con en CLIPS se muestra en la Figura 20.

Figura 20 Representación grafica del Laboratorio de Interfaces Inteligentes, obtenida

a partir de una representación simbólica.

70
Programas en ROBEL

Apéndice D Programas en ROBEL

a) Salida del planeador
mvto 8.362 8.170 1 @0
mvto 8.723 10.340 1 @1
mvto 9.085 12.510 1 @2
mvto 9.447 14.680 1 @3
* Destine reached 1
mvto 9.808 16.850 1 @4
mvto 10.362 15.830 1 @5
mvto 10.723 13.660 1 @6
mvto 11.085 11.490 1 @7
mvto 11.447 9.320 1 @8
* Destine reached 2
mvto 11.808 7.150 1 @9
mvto 12.362 8.170 1 @10
mvto 12.723 10.340 1 @11
mvto 13.085 12.510 1 @12
mvto 13.447 14.680 1 @13
* Destine reached 3
mvto 13.808 16.850 1 @14
mvto 14.362 15.830 1 @15
mvto 14.723 13.660 1 @16
mvto 15.085 11.490 1 @17
mvto 15.447 9.320 1 @18
* Destine reached 4
mvto 15.808 7.150 1 @19
mvto 16.362 8.170 1 @20
mvto 16.723 10.340 1 @21
mvto 17.085 12.510 1 @22
mvto 17.447 14.680 1 @23
* Destine reached 5
mvto 17.808 16.850 1 @24
mvto 18.362 15.830 1 @25
mvto 18.723 13.660 1 @26
mvto 19.085 11.490 1 @27
mvto 19.447 9.320 1 @28
* Destine reached 6
mvto 19.808 7.150 1 @29
mvto 20.362 8.170 1 @30
mvto 20.723 10.340 1 @31
mvto 21.085 12.510 1 @32
mvto 21.447 14.680 1 @33
* Destine reached 7

71
Programas en ROBEL

mvto 21.808 16.850 1 @34

mvto 22.362 15.830 1 @35
mvto 22.723 13.660 1 @36
mvto 23.085 11.490 1 @37
mvto 23.447 9.320 1 @38
* Destine reached 8
mvto 23.808 7.150 1 @39
mvto 24.362 8.170 1 @40
mvto 24.723 10.340 1 @41
mvto 25.085 12.510 1 @42
mvto 25.447 14.680 1 @43
* Destine reached 9
mvto 25.808 16.850 1 @44
mvto 26.362 15.830 1 @45
mvto 26.723 13.660 1 @46
mvto 27.085 11.490 1 @47
mvto 27.447 9.320 1 @48
* Destine reached 10
mvto 27.808 7.150 1 @49

b) Programa que toma las fotos

mv 0 0.70 0 @1
tap @2
mv 0 0.70 0 @3
tap @4
mv 0 0.70 0 @5
tap @6
mv 0 0.70 0 @7
tap @8
mv 0 0.70 0 @9
tap @10
mv 0 0.70 0 @11
tap @12
mv 0 0.70 0 @13
tap @14
mv 0 0.70 0 @15
tap @16
mv 0 0.70 0 @17
tap @18

72
Bibliografía

5 Bibliografía
• R.C. Arkin and R. Murphy, "Autonomous Navigation in a
Manufacturing Environment.", IEEE Transaction on Robotics and
Automation 6(4): pp. 445-452, 1990.
• BeeSoft, “User’s guide and Software Reference”, 1997, Real World
Interface, Inc.
• Chen S., “Quicktime VR—An Image-Based Approach to virtual
Enviroment Navigation”, Proc. SIGGRAPH ’95, pp. 29-38, Aug. 1995
• Debevec P., “Pursuing Reality with Image-Based Modeling, Rendering,
and Lighting”, Second Workshop on 3D Structure from Multiple Image
of Large-scale Environments, June 2000.
• Dersch H, http://www.fh-furtwangen.de/~dersch.
• Watson Des, “High-Level Languages and Their compilers”, 1989,
Wokingham, England, Addison-Wesley.
• Froufe A, “Java 2 Manual de usuario y tutorial”, 2000, Alfaomega.
• Giarratano, J., and Riley, G. “Expert Systems: Principles and
Programming”, 3rd Edition, Boston, PWS Publishing Company, 1998.
• Gradecki Joe, “Realidad Virtual Construcción de proyectos”, 1995,
PCVR Magazine.
• Hernandez E, Vázquez G, “Interfaz grafica 3D para similar y controlar
robots móviles usando realidad virtual”, 2002, México.
• Ingermar J. Cox & Gordon T. Wilfong, “Autonomous Robot Vehicles”,
1990, Springer-Verlag.
• Latombe, Jean Claude, “Robot motion planning”, 1991, Kluwer
Academic Publishers.
• McAllister, Nyland Popescu, Lastra McCue, “Real Time Rendering of
Real World Enviroments”, Rendering Techniques ’99 Proc. of
Eurographics Workshop o Rendering.

73
Bibliografía

• Peleg S, Ben-Ezra M, Pritch Y, “Omnistereo: Panoramic Stereo

Imaging”, IEEE Transaction on pattern analysis and machine
intelligence, Vol 23, No. 3. March 2001.
• Pitas, Ioannis, “Digital image processing algorithms and applications”,
2000, J. Wiley.
• Rigg J, http://www.panoguide.com.
• Seitz, Dyer, “Physically-Valid View Synthesis by Image Interpolation”,
Workshop on Representations of Visual Scenes, 1995, Cambrige MA.
• Spragins J-D, “Telecommunications, protocols and design”, 1991,
Reading, Massachusetts, Addison-Wesley.
• Terrence W. Pratt & Marvin V. Zelkowitz, “Lenguajes de programación
diseño e implementación”, 1998, Prentice Hall.
• Tomás Lozano-Pérez, “An algorithm for planning collision-free path
among polyhedral obstacles”, Communications of the ACM, vol. 22,
pp.560-570, October 1979.
• Vera B. Anand, “Computer Graphics and Geometric Modeling for
Engineers”, 1993, John Wiley & Sons, Inc.

74