P. 1
TES578

TES578

|Views: 718|Likes:
Published by Luis Martinez

More info:

Published by: Luis Martinez on Aug 22, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

04/08/2013

pdf

text

original

Sections

  • 1.1 Motivación y alcance de la tesis
  • 1.2 Objetivos
  • 1.3 Contribuciones
  • 1.4 Organización de la tesis
  • 2.1 Componentes
  • 2.2 Especificaciones técnicas
  • 2.3 Componentes electrónicos
  • 2.3.1 Tarjeta del Microcontrolador
  • 2.3.2 Tarjeta de Alimentación y Motores
  • 2.3.3 Tarjeta de Sónares
  • 2.4 Software
  • 2.4.1 ARIA
  • 2.4.2 Saphira
  • 2.4.3 PAI- Pioneer Application Interface
  • 2.5 Simuladores
  • 2.5.1 Pioneer
  • 2.5.2 Java Mobile Robots
  • 2.5.2.1 Interfaz con Saphira
  • 2.5.2.2 Aplicación de monitorización y control
  • 3.1 Introducción
  • 3.2 Preprocesado
  • 3.2.1 Conversión de imágenes en color a niveles de gris
  • 3.2.2 Suavizado Gaussiano
  • 3.3 Segmentación
  • 3.3.1 Detectores de bordes
  • 3.3.1.1 Operadores de derivación
  • 3.3.1.2 Detector de bordes de Sobel
  • 3.3.1.3 Detector de bordes de Canny
  • 3.4 Descripción
  • 3.4.1 Códigos de cadena
  • 3.4.2 Signaturas
  • 3.4.3 Aproximaciones poligonales
  • 3.5 Operaciones Morfológicas
  • 3.5.1 Dilatación
  • 3.5.2 Adelgazamiento
  • 4.1 Introducción
  • 4.2 Características
  • 4.3 Representación Situación-Acción
  • 4.4 Arquitectura de subsunción de Brooks
  • 4.5 Limitaciones
  • 5.1 Introducción
  • 5.2 Arquitectura
  • 5.3 Módulos funcionales
  • 5.3.1 Capa Seguir Objeto
  • 5.3.2 Capa Detectar Obstáculos
  • 5.4 Selección de Algoritmos
  • 5.5 Diagrama de Clases
  • 5.6 Diagrama de Secuencias
  • 6.1 Introducción
  • 6.2 Adquisición de imágenes
  • 6.3 Detección de bordes
  • 6.4 Dilatación
  • 6.5 Adelgazamiento
  • 6.6 Algoritmo de seguimiento de bordes
  • 6.7 Algoritmo de identificación del círculo
  • 6.8 Localización del objeto
  • 6.9 Controlador del robot
  • 6.10 Interfaz de Usuario
  • Resultados y Conclusiones
  • Trabajos Futuros
  • Bibliografía

Benemérita Universidad Autónoma de Puebla Facultad de Ciencias de la Computación

DISEÑO Y CONSTRUCCIÓN DE UNA ARQUITECTURA DE CONTROL REACTIVO PARA NAVEGACIÓN AUTÓNOMA DE ROBOTS MÓVILES CON BASE EN LA VISIÓN

Tesis Profesional
Que para obtener el Titulo de: Licenciado en Ciencias de la Computación Presenta: C. Javier Herrera Vega Asesor: Dr. Rodrigo Montúfar Chaveznava Coasesor: MC. Alfonso Garcés Báez

INDICE
Capítulo I Introducción ....................................................................................................... 1
1.1 Motivación y alcance de la tesis ................................................................................... 1 1.2 Objetivos....................................................................................................................... 3 1.3 Contribuciones.............................................................................................................. 4 1.4 Organización de la tesis................................................................................................ 4

Capítulo II El robot móvil Pioneer 2-CE............................................................................ 6
2.1 Componentes ................................................................................................................ 7 2.2 Especificaciones técnicas ............................................................................................. 8 2.3 Componentes electrónicos.......................................................................................... 10 2.3.1 Tarjeta del Microcontrolador............................................................................... 10 2.3.2 Tarjeta de Alimentación y Motores ..................................................................... 11 2.3.3 Tarjeta de Sónares ............................................................................................... 11 2.4 Software...................................................................................................................... 11 2.4.1 ARIA ................................................................................................................... 12 2.4.2 Saphira ................................................................................................................. 12 2.4.3 PAI- Pioneer Application Interface ..................................................................... 12 2.5 Simuladores ................................................................................................................ 12 2.5.1 Pioneer ................................................................................................................. 12 2.5.2 Java Mobile Robots ............................................................................................. 13 2.5.2.1 Interfaz con Saphira...................................................................................... 15 2.5.2.2 Aplicación de monitorización y control ....................................................... 16

Capítulo III Procesamiento de imágenes.......................................................................... 18
3.1 Introducción................................................................................................................ 18 3.2 Preprocesado............................................................................................................... 20 3.2.1 Conversión de imágenes en color a niveles de gris ............................................. 20 3.2.2 Suavizado Gaussiano........................................................................................... 21 3.3 Segmentación ............................................................................................................. 23 3.3.1 Detectores de bordes............................................................................................ 24 3.3.1.1 Operadores de derivación ............................................................................. 24 3.3.1.2 Detector de bordes de Sobel ......................................................................... 26 3.3.1.3 Detector de bordes de Canny........................................................................ 27 3.4 Descripción................................................................................................................. 29 3.4.1 Códigos de cadena ............................................................................................... 30 3.4.2 Signaturas ............................................................................................................ 32 3.4.3 Aproximaciones poligonales ............................................................................... 34 3.5 Operaciones Morfológicas.......................................................................................... 34 3.5.1 Dilatación ............................................................................................................ 35 3.5.2 Adelgazamiento ................................................................................................... 37

i

Capítulo IV Arquitecturas de control reactivo................................................................ 39
4.1 Introducción................................................................................................................ 39 4.2 Características............................................................................................................. 40 4.3 Representación Situación-Acción............................................................................... 41 4.4 Arquitectura de subsunción de Brooks....................................................................... 42 4.5 Limitaciones ............................................................................................................... 43

Capítulo V Diseño del sistema ........................................................................................... 44
5.1 Introducción................................................................................................................ 44 5.2 Arquitectura ................................................................................................................ 44 5.3 Módulos funcionales .................................................................................................. 46 5.3.1 Capa Seguir Objeto.............................................................................................. 46 5.3.2 Capa Detectar Obstáculos.................................................................................... 47 5.4 Selección de Algoritmos............................................................................................. 47 5.5 Diagrama de Clases .................................................................................................... 49 5.6 Diagrama de Secuencias............................................................................................. 50

Capítulo VI Implementación del sistema ......................................................................... 52
6.1 Introducción................................................................................................................ 52 6.2 Adquisición de imágenes............................................................................................ 52 6.3 Detección de bordes ................................................................................................... 55 6.4 Dilatación ................................................................................................................... 58 6.5 Adelgazamiento .......................................................................................................... 60 6.6 Algoritmo de seguimiento de bordes.......................................................................... 60 6.7 Algoritmo de identificación del círculo...................................................................... 63 6.8 Localización del objeto............................................................................................... 64 6.9 Controlador del robot ................................................................................................. 66 6.10 Interfaz de Usuario ................................................................................................... 68

Resultados y Conclusiones ................................................................................................. 71 Trabajos Futuros ................................................................................................................ 72 Bibliografía.......................................................................................................................... 73

ii

es un ejemplo generalmente utilizado como caso de estudio en el desarrollo de sistemas autónomos de control y en la percepción basada en una variedad de sensores. Sin embargo. por sus características. diversos investigadores e ingenieros se ven obligados a realizar nuevos y variados estudios. Por este motivo. Sin duda. sin intervención humana directa. especialmente aquellas que involucran la interacción y cooperación con el ser humano. El presente proyecto de tesis se enfoca en el tema de visión computacional para la navegación autónoma de un robot móvil con una arquitectura de control basada en el comportamiento reactivo. en este trabajo se presenta un sistema de control para un robot móvil con el cual es posible manifestar comportamientos de forma adecuada. Cuando se inicia un proyecto. Para establecer con mayor precisión las áreas que estuvieron involucradas en la solución del problema se definió el punto de partida y los recursos básicos con los que se contaba. En general.1 Motivación y alcance de la tesis Actualmente los robots móviles son una de las tecnologías que más interés ha despertado en la industria por cuanto a su posible aplicación en una gran variedad de tareas. además el robot se encuentra inmerso en un ambiente no estructurado. en función de los resultados.Capítulo I Introducción 1. 1 . determinar a priori cuales van a ser los límites del mismo resulta una tarea difícil ya que es el mismo trabajo quien va delimitando. al igual que búsquedas y creaciones de nuevas aplicaciones relacionadas con el control robótico. la solución a este problema ha requerido de una tarea de investigación en muchas áreas por lo que nos encontramos frente a un problema de carácter multidisciplinario. En este caso. El problema de control de un robot móvil. es posible realizar una declaración de intenciones sobre cuales serian aquellos aspectos que en mayor o menor profundidad se desea abarcar. realizando una tarea para la cual ha sido destinado. las áreas a explorar y los mismos limites. el objetivo principal del sistema fue el reconocimiento y seguimiento de un objeto característico que sirve de guía en la navegación del robot.

como son: • Robótica: El estudio de las bases de la robótica. escalable y adaptable con la idea de que pueda integrarse. que sirva de comparación con otras técnicas utilizadas para el mismo propósito. diseñado con fines de investigación y aplicaciones prácticas. como una aportación más al estudio de la navegación de robots móviles aplicando técnicas del procesamiento digital de imágenes. la cual es proporcionada por una cámara dispuesta en el cuerpo del robot.Primeramente se dispuso de un robot móvil equipado con los elementos necesarios para navegar en un entorno del mundo real. las pruebas e implementación de las rutinas básicas de movimiento. permitiendo el aumento en la autonomía del robot. ya que la navegación de un robot móvil está sujeta a la percepción de su entorno mediante sensores. Teniendo en cuenta estos factores se definieron las áreas involucradas en la solución del problema junto con las tareas especificas a realizar. 2 . los cuales pueden ser de muchos tipos. evaluación e implementación de técnicas de adquisición y procesamiento de imágenes • Reconocimiento de patrones: El estudio e implementación de alguno de los algoritmos existentes para la identificación de objetos en una imagen. así como las arquitecturas de control existentes y los aspectos de percepción y navegación. o ser integrado. La definición del problema y el planteamiento del punto de partida fueron de utilidad para establecer fielmente las razones que motivaron a la realización de este trabajo: En primer lugar. En este caso se determinó que la percepción del entorno fuera mediante visión. Además. • Procesamiento digital de imágenes: El estudio. con otros sistemas sin mayor dificultad. la presentación de un sistema modular flexible. • Operación del robot: El estudio de su modo de operación.

de los dispositivos utilizados. el hardware utilizado para proveer la visión no está restringido solo al tipo de cámara utilizado durante el desarrollo del proyecto. con lo que cumplimos con el objetivo general. Finalmente. El diseño de la arquitectura de control es pieza fundamental en la organización del sistema ya que guía el desarrollo de cada uno de los bloques que integran al sistema. independiente. Como primer objetivo particular deseamos realizar un sistema de adquisición de imágenes utilizando herramientas que optimizan este proceso. el conocimiento del modo de operación y los conceptos fundamentales del manejo del robot permiten la implementación del sistema básico de movimiento para que el robot sea capaz de seguir al objeto. que una vez integrados. así como la comunicación entre todos los componentes tanto de software como de hardware. 3 . El segundo objetivo particular ha sido el estudio y aplicación de las técnicas del procesamiento digital de imágenes empleadas en el área de robótica. lo cual proporciona flexibilidad al sistema. con el fin de poder evaluar de forma independiente cada una de estas tareas. se han conseguido los módulos.1. Para alcanzar esta meta fue necesario dividir el problema y establecer objetivos específicos para cada una de las áreas involucradas para la solución del problema. sino que puede ser reemplazado por algún otro que proporcione un mejor desempeño para el sistema.2 Objetivos El objetivo general del proyecto es el diseño y desarrollo de un sistema de control a través de una arquitectura robótica reactiva para la navegación de un robot móvil a través de la visión. empleando el seguimiento de un objeto en movimiento que sirva de guía. en la medida de lo posible. con la finalidad de desarrollar un módulo para el reconocimiento del objeto característico en las imágenes. Por ejemplo. dan como resultado el sistema de control completo. Una vez alcanzadas cada una de estas metas. su fiabilidad y desempeño en todo el sistema.

especificaciones técnicas. el robot Pioneer 2-CE. • En el capítulo 3 se presenta una introducción del procesamiento digital de imágenes y la descripción de algoritmos utilizados en el desarrollo del sistema que resuelven el problema de detección. Este módulo es adaptable a proyectos similares que buscan ampliar cada vez más la autonomía del robot. los robots con estas características son empleados para la detección y/o desarme de minas personales. dimensiones y aplicaciones en el campo práctico y de investigación.1. Se describen cada uno de sus componentes.4 Organización de la tesis La tesis comprende varios capítulos en los que se describen desde los antecedentes y conceptos fundamentales para hallar y plantear una solución a los problemas presentes en el trabajo. Actualmente. arquitectura. • En el capítulo 2 se presenta la plataforma móvil.3 Contribuciones La principal aportación de este proyecto es un módulo de control para la navegación autónoma de un robot móvil basado en una arquitectura robótica reactiva. 1. 4 . también se mencionan los simuladores disponibles y el software de control básico disponible. Además se contribuye a la investigación en el procesamiento digital de imágenes aplicadas a la navegación. con la finalidad de poseer una referencia más en el desarrollo de arquitecturas de control como las que se describirán a lo largo de este documento. en países que han estado en conflicto bélico. hasta la implementación del sistema y descripción de algoritmos y herramientas utilizadas. Por lo cual. se espera con este trabajo contribuir también en este tipo de tareas. Una tarea de aplicación más es el transporte y/o manipulación de sustancias tóxicas o peligrosas o cualquier otra actividad que ponga en estado de riesgo al ser humano. Los resultados obtenidos con trabajos similares son utilizados para tareas de ayuda a discapacitados y visitas virtuales a fábricas y museos.

los módulos que integran el sistema y diagramas de clases. • En el capitulo 5 se describe el diseño del sistema. 5 . • Por ultimo presentamos los resultados obtenidos y las conclusiones de la elaboración de este trabajo. además de la descripción de los algoritmos implementados para realizar la detección y el control del robot. la arquitectura desarrollada.• El capítulo 4 trata el tema de las arquitecturas de control reactivo. • El capitulo 6 presenta la implementación del sistema con las herramientas utilizadas como los lenguajes de programación y herramientas auxiliares. haciendo una reseña de las arquitecturas más importantes.

CE. dentro de la cual se encuentra el Pioneer 2-DX.Capítulo II El Robot móvil Pioneer 2-CE Pioneer es una familia de robots móviles desarrollados por la empresa “ActivMedia Robotics”. Figura 2-1 Pioneer 2-CE El Pioneer 2-CE (Figura 2-1) es un robot móvil. Esta diseñado tanto para propósitos de investigación como para aplicaciones reales entre las cuales podemos mencionar: • • • • • • Teleoperación Localización Monitoreo Reconocimiento Visión Cooperación 6 . AT entre otros modelos. versátil e inteligente construido bajo el modelo cliente-servidor como todos los robots de ActiveMedia. ágil.

2. laboratorios o salones de clases. La arquitectura está basada en un modelo cliente/servidor.Su tamaño lo hace ideal para desplazarse por lugares con espacio reducido como oficinas.1 Componentes Estos robots contienen los componentes básicos para sensar y navegar en un ambiente del mundo real. atendiendo a las peticiones de los clientes que son los programas de alto-nivel que proporcionan inteligencia al robot. La comunicación con los programas clientes almacenados o ejecutados desde una PC puede ser de diversas maneras según lo requiera la aplicación (Fig 2-2). entre los que se incluyen: • • • • • • • • • • Baterías (como fuente de alimentación) Motores Ruedas Codificadores de posición y velocidad Anillo de sónares Microcontrolador Tarjeta de sónares Tarjeta de alimentación P2OS (software servidor) API ARIA para desarrolladores Todos los dispositivos son manejados a través del microcontrolador encontrado en el interior del robot. donde el robot cuenta con un software servidor que es el encargado del manejo de todos los dispositivos para interactuar con su entorno. 7 .

El cuerpo del robot está hecho de fuerte aluminio y ruedas de goma reforzadas. sus dimensiones cumplen con las especificaciones para competir dentro de la liga media de la RoboCup (Figura 2-3).2 Especificaciones técnicas El Pioneer tiene un peso de 9 kg. 8 . estas características permiten que el Pioneer 2 soporte una carga de hasta 23 Kg.• • • • Inalámbrica vía radio modem Conexión directa por cable vía RS232 con una Laptop sobre el robot Conexión directa por cable vía RS232 con una PC fuera del robot Ethernet inalámbrico Figura 2-2 Tipos de conexión del robot servidor a la PC cliente 2. de peso adicional.

con esta distribución se logra un rastreo de 180 grados para la detección de obstáculos. Este robot es holonómico1 y puede rotar en el mismo lugar moviendo ambas ruedas o puede girar alrededor de una rueda fija en un círculo de 32 cm de radio. Dimensiones físicas del Pioneer 2-CE Los motores impulsores utilizan engranes con una relación 19. y posee una pequeña rueda trasera que sirve para el balance. La posición de los sónares es: uno a cada lado del robot y seis al frente separados en un intervalo de 20 grados (Fig 2-4). a velocidades lentas puede llevar una carga de hasta 23 kg. Adicionalmente cuenta con un arreglo de sónares dispuesto en la parte superior-frontal del robot y consta de 8 transductores que proveen la detección de objetos e información de alcance. así como permiten la navegación alrededor de obstáculos.Figura 2-3. En superficies planas puede alcanzar una velocidad de 1. la cual debe ser balanceada para una operación efectiva del robot. 1 Un robot holonómico es aquel en que todos sus grados de libertad son controlables. 9 .5:1 y contienen codificadores de 500-pulsos.6 m/s.

El microcontrolador también posee una memoria RAM de 32 KB. y un bus de 8 bits.Figura 2-4 Arreglo de sonares La velocidad de disparo en cada sónar es de 25Hz (40 milisegundos por sónar) y se tiene un rango de sensibilidad que va desde los 10 cm. 2. no son detectados). Todos los puertos están disponibles y pueden ser manipulados a través del P2OS (Pioneer 2 Operating System). el rango de sensibilidad puede ser modificado manualmente según sea el caso para cada aplicación y circunstancia del medio en el que se encuentre el robot. hasta más de 5 metros (los objetos cercanos a menos de 10 cm.3 Componentes electrónicos El funcionamiento del Pioneer 2 esta a cargo de tres tarjetas principales que son: • • • Microcontrolador Alimentación/Motores Sónares 2. dos puerto seriales RS232 y varios puertos digital y analogicodigital. con memoria flash-ROM de 32KB.1 Tarjeta del Microcontrolador El microcontrolador del Pioneer 2-CE utiliza un microprocesador Siemens 88C166 a 20MHz. 10 .3.

Linux.) a cada componente dentro del robot. Un cable conductor de señal conecta a la tarjeta con el microcontrolador para llevar a cabo la comunicación. 2.2.2 Tarjeta de Alimentación y Motores Está encargada de suministrar el voltaje necesario (12 y 5 volts. 2. Consiste en un multiplexor para accionar cada sónar.Macintosh. disponible para diferentes plataformas (UNIX.3. y también contiene los componentes electrónicos necesarios para el accionamiento de los motores de impulso de las llantas. contiene los conectores accesibles para la alimentación del hardware adicional.Win32) este software incluye: • • • • • • ARIA (ActivMedia Robotics Interface for Application) Suite de desarrollo cliente de Saphira con Colbert Ayllu Simulador Pioneer Pioneer LOGO Pioneer Application Interface (PAI) 11 .4 Software El Pioneer 2-CE viene acompañado por una variedad de software de desarrollo de robótica móvil.3.3 Tarjeta de Sónares Esta tarjeta controla independientemente cada sónar dispuesto en el arreglo de sónares.

5 Simuladores 2. este software es el encargado de realizar las tareas de más bajo nivel como el control de motores. El papel fundamental de ARIA se encuentra del lado de las aplicaciones “inteligentes” del cliente en la arquitectura clienteservidor.1 Pioneer Es posible realizar pruebas con este tipo de robots sin ponerlos en riesgo cuando se comienza a experimentar con ellos haciendo uso de simuladores.2 Saphira Saphira es un software que provee toda la funcionalidad de ARIA además de proporcionar rutinas con las que es más fácil y simple escribir nuevas rutinas de control para el robot. 12 . 2. o también para estudiar su 2 API son las siglas en inglés de Application Programming Interface y básicamente designan a un conjunto de funciones y procedimientos que los programadores pueden utilizar en sus propios programas.4.4.1 ARIA ARIA es una librería de desarrollo orientada a objetos escrita en C++.Pioneer Application Interface PAI –Pioneer Application Interface es una librería de funciones y definiciones para el control de robots móviles.4. 2. 2. y cuenta con un simulador y una aplicación cliente que permite el manejo del robot. PAI no intenta remplazar a Saphira pero facilita el aprendizaje de operación de los Pioneers.3 PAI.2. la adquisición de la información de los sensores o el manejo de cualquier otro accesorio. PAI trabaja conjuntamente con el entorno de desarrollo de aplicaciones robóticas de la SRI International’s Saphira reuniendo muchas de sus rutinas de control de bajo nivel en una API2 simple y más fácil de manejar. provee una comunicación cercana con el software servidor P2OS (Pioneer 2 Operating System) incluido en el microcontrolador del robot.5.

5.comportamiento y control cuando se cuenta con el robot físicamente. el cual es un software que actúa como el robotservidor al que se pueden conectar los programas clientes y ejecutar rutinas de control. El sistema dispone de una aplicación cliente. actualizar su situación en el mundo que se encuentra especificado. se podrá conectar el sistema al simulador de robots de Saphira (Pioneer). Figura 2-5 Simulador Pioneer de Saphira 2. y también a los robots reales que se gestionen con dicha librería. sobre la que se cargarán los robots que se desea probar. y proporcionar al cliente los datos que se soliciten.2 Java Mobile Robots Otro simulador existente para robots Pioneer es JMR (Java Mobile Robots) el cual es un entorno de simulación de robots hecho en el lenguaje de programación Java que permite la simulación y control de robots. Se persiguen con este entorno dos objetivos fundamentales: uno es definir una interfaz de comunicación de Java con la librería Saphira de control de robots. y de una aplicación servidor que se encarga de llevar un control de los robots conectados. Conviene resaltar aquí la modularidad que 13 . El simulador puede ser configurado para cada uno de los modelos de robots de ActivMedia para llevar a cabo la simulación con el robot requerido. De este modo. Saphira proporciona un simulador llamado Pioneer (Figura 2-5).

y que hace posible la adaptación del programa a otras librerías de control de robots. La estructura de Java permite definir un esqueleto básico sobre el que se puede ir modificando o ampliando características de forma sencilla. El entorno JMR incluye: • • • • • Simulador tridimensional de robots móviles Interfaz con Saphira Aplicación de monitorización y control de robots Librería para programación de robots en Java (TM) Librerías de apoyo 14 . De esta forma. mediante un simulador tridimensional (Figura 2-6) propio. algunas de las cuales son utilizadas por dichos programas. existe un programa cliente-servidor que permite la gestión de robots.permite Java . que permite la prueba de robots y procesos sobre el mismo sin necesidad de realizar un programa adicional. se dispone de un sistema auto-integrado. que permita realizar sencillas modificaciones o actualizaciones del mismo. además de la comunicación con Saphira. y otras que facilitarán la elaboración de procesos en los robots por parte del usuario. modular y fácilmente portable. añadiendo nuevas clases que extiendan o sobreescriban a las anteriores. Para todo lo anterior. El otro objetivo que se persigue es proporcionar un sistema propio de simulación. así como algunas librerías auxiliares.

5.Figura 2-6 Simulador de robots móviles 3D Sus características principales son: • • • • • • Simulación de múltiples robots simultáneamente Visualización de mundos en tres dimensiones Errores en las medidas configurables por el usuario (para añadir realismo) Ofrece al usuario facilidades para la simulación de la toma de los datos de robots en sus programas Compatibilidad con los formatos de fichero de Saphira Incluye distintos tipos de iluminación. así como la incorporación de objetos VRML.2. sino simplemente de un programa que se deja ejecutando y permite la comunicación con Saphira. dando una mayor riqueza a la definición de los mundos 2. cámaras.1 Interfaz con Saphira En esta interfaz engloba tanto la conexión con el simulador Pioneer como la conexión con un robot real a través de un puerto serie utilizando Saphira. Este tipo de servidor no dispone de ninguna aplicación visual de monitorización. materiales. tanto de los robots como en los objetos del entorno. texturas. 15 .

16 .2 Aplicación de monitorización y control Se trata de un programa para manejar los distintos robots que queremos conectar (Figura 27). El programa está preparado para soportar varios robots simultáneamente (aunque si se está comunicando con Saphira.Para la comunicación con Saphira se emplea JNI (Java Native Interface).2. También dispone de controles para elegir a qué servidor conectarse (al simulador Java. Esto permite la comunicación con un servidor situado en una máquina remota. 2. se definen en una librería un conjunto de funciones escritas en C que interactúa con Saphira. y desde Java se define el puente para poder llamar a las funciones de dicha librería. estado actual. indicando la dirección donde se encuentra el servidor. etc). una utilidad de Java que permite incorporar a nuestro código en Java fragmentos de código escritos en otros lenguajes de programación como C. sólo se permitirá uno por las limitaciones de Saphira). y llevar un control de los datos de cada robot (lecturas de sónares. Así. permite añadir y quitar robots del servidor. parámetros de configuración. y se conseguiría con ello el mismo efecto que lanzando varias aplicaciones cliente. una por cada robot. o a un robot real a través de Saphira por un puerto serie dado).5. conociendo su dirección IP y el puerto por el cual comunicarse. imagen de la cámara. Además. al simulador Saphira.

Figura 2-7 Aplicación de monitorización y control de robots 17 .

la segmentación autónoma de la imagen es una de las labores más difíciles del tratamiento digital de imágenes. la cual actualmente es utilizada en muchas aplicaciones tanto en robótica como en la industria para mejorar el control de calidad o cualquier otro proceso que requiera supervisión óptica para la toma de decisiones. A la salida del proceso de segmentación habitualmente se tienen los datos de píxel en bruto. la segmentación consiste en partir una imagen de entrada en sus partes constituyentes u objetos. El segundo aspecto ha dado origen a una de las más recientes áreas de investigación que es la visión por computadora. Mencionaremos de forma breve las etapas fundamentales del procesamiento que es preciso realizar para la interpretación de una imagen. algunos ejemplos podrían ser las cámaras digitales y los escáneres además de que existen dispositivos para digitalizar las señales analógicas como son los frame grabbers. La función básica de esta etapa es mejorar la imagen de forma que se aumenten las posibilidades de éxito en los procesos posteriores.1 Introducción El interés por los métodos de tratamiento digital de imágenes se deriva de dos áreas principales de aplicación: la mejora de la información pictórica para la interpretación humana y el procesamiento de los datos de la escena para la percepción autónoma de una máquina. De forma general. El dispositivo empleado queda determinado por la aplicación. Una vez segmentada la imagen hay que decidir la representación que daremos a los datos. La primera etapa del proceso es la adquisición de imágenes en forma digital. software y recursos teóricos. El proceso de visión comprende un amplio rango de hardware.Capítulo III Procesamiento de imágenes 3. para esto es necesario un dispositivo (hardware) con la posibilidad de digitalizar imágenes del mundo real. 18 . La siguiente etapa trata del preprocesamiento de esa imagen. es decir. que constituyen el contorno de una región o bien todos los puntos de una región determinada. Seguido a este proceso.

También se debe especificar un método para describir los datos de forma que se resalten los rasgos de interés. La representación como un contorno es la adecuada cuando el interés radica en las características de la forma exterior. La última etapa incluye el reconocimiento e interpretación. también llamada selección de rasgos. La Figura 3-1 muestra las etapas descritas. 19 . El reconocimiento es el proceso que asigna una etiqueta a un objeto basándose en la información proporcionada por sus descriptores. La descripción. consiste en extraer rasgos con alguna información cuantitativa de interés o que sean fundamentales para diferenciar una clase de objetos de otra.dictaminar si los datos representan un contorno o una región completa. Adquisición de imágenes Reconocimiento e interpretación Preprocesado Segmentación Representación y descripción Figura 3-1 Etapas del procesamiento de imágenes En las siguientes secciones describiremos las técnicas utilizadas en el desarrollo del sistema para las etapas antes mencionadas a partir del preprocesamiento. La interpretación implica asignar un significado a un conjunto de objetos reconocidos.

3+G*0. Las principales técnicas para la mejora de la imagen consisten en filtros para la eliminación de ruido. Esto es debido a la respuesta del ojo al espectro visible la cual se puede observar en la Figura 32. Por esa razón.3. iluminación. 3.11 20 . el cálculo del equivalente blanco y negro (escala de grises o luminancia) de la imagen debe realizarse como una media ponderada de las distintas componentes de color de cada píxel.2. Figura 3-2 Longitudes de onda La ecuación de la luminancia (Y) nos muestra la expresión matemática de ese fenómeno y los factores de ponderación de cada componente de color nos indican la sensibilidad del ojo humano a las frecuencias del espectro cercanas al rojo (R).1 Conversión de imágenes en color a niveles de gris El ojo humano percibe distintas intensidades de luz en función del color que observe. verde(G) y azul(B).59+B*0.2 Preprocesado El principal objetivo de las técnicas de mejora es procesar una imagen de forma que resulte más adecuada que la original para una aplicación específica. contraste y cualquier método que mejore la imagen según lo requiera la aplicación. Dicha ecuación es: Y = R*0.

Figura 3-3 Distribución Gaussiana unidimensional 21 . La convolución es realizada por una máscara que representa la función de distribución Gaussiana. eliminar detalles y remover el ruido en la imagen. V ) 3 3. azul y asignar el valor resultante nuevamente a cada componente que forman el píxel de la imagen. En la Figura 3-3 apreciamos esta distribución unidimensional. imagen( x. G ) + imagen( x. y. Una forma alternativa para la conversión a escala de grises es calcular el promedio de los valores de intensidad de cada canal. verde. y. y. rojo.Por tanto. para realizar esta conversión basta con aplicar la ecuación a cada píxel de la imagen en color.2 Suavizado Gaussiano El operador de suavizado Gaussiano es un operador de convolución bi-dimensional que es usado para difuminar imágenes. R ) + imagen( x. El resultado es una nueva matriz de un byte por píxel que daría la información de luminancia.2. La función de distribución Gaussiana unidimensional tiene la forma: donde σ es la desviación estándar de la distribución. y ) = imagen(x.

0 Figura 3-5 Aproximación discreta de la función Gaussiana bidimensional con σ = 1.En dos dimensiones tenemos: Figura 3-4 Función de distribución Gaussiana en bidimensional La idea del suavizado Gaussiano es usar esta distribución bidimensionales como una función de “punto de propagación” y esta es llevada a cabo mediante una operación de convolución.0 Una vez calculados los valores de la máscara de convolución el suavizado puede ser realizado usando métodos de convolución estándar. La siguiente figura muestra la máscara de convolución que aproxima a la función Gaussiana con σ = 1. Ya que una imagen es almacenada como una colección discreta de píxeles necesitamos realizar una aproximación discreta de la función antes de poder ejecutar la convolución. El grado de suavizado está determinado 22 .

por la desviación estándar σ (un valor alto para σ conlleva a tener una máscara de convolución de mayor dimensión). Esto 23 . Suavizado con σ=4. Las Figura 3-6 presenta una imagen y los diferentes valores para σ igual a 1. d) 3. En general. la segmentación deberá detenerse cuando los objetos de interés hayan sido aislados. éste es el primer paso en el análisis de la imagen. Un borde es el límite entre un objeto y el fondo e indica el limite entre objetos traslapados. La detección de bordes es una de las operaciones más comúnmente usadas en el análisis de imágenes. La razón para esto es que los bordes forman el contorno de un objeto.3 Segmentación Cuando se ha alcanzado el nivel deseado de mejora de la imagen para los propósitos específicos de la aplicación se comienza con la etapa de segmentación. b)Suavizado con σ=1. a) b) c) d) Figura 3-6 a) Imagen Original. El nivel al que se lleva a cabo esta subdivisión depende del problema a resolver. 2 y 4 respectivamente que intensifican el nivel de difuminado. La segmentación subdivide una imagen en sus partes constituyentes u objetos. la segmentación autónoma es una de las tareas más difíciles del procesamiento de imágenes. suavizado ó borrosidad. Esto es. c) Suavizado con σ=2. Esta etapa determina el éxito o el fracaso del análisis.

Por esta razón.y)=A(x.3. con respecto a las direcciones principales x y y.1.3. ∇x1A(x.1 Operadores de derivación Ya que un borde es definido como un cambio abrupto en los niveles de gris. En su lugar. todos los objetos pueden ser localizados y sus propiedades básicas como área.A(x-1. es importante considerar los cambios de nivel en varias direcciones. la derivada en un píxel es aproximada por la diferencia en los niveles de gris sobre alguna región local.y) .y) ∇y1A(x.y) . Existe una gran cantidad de algoritmos diseñados para realizar la extracción de bordes en una imagen. y la razón de cambio en los niveles de gris en una imagen es mayor cerca de un borde y menor en áreas constantes. Una interpretación de una derivada es como la razón de cambio de una función. cada uno con sus ventajas y desventajas sujetos al nivel de aplicación.y)=(∂A/∂x . Ya que una imagen es bidimensional.1 Detectores de bordes 3. son usadas las derivadas parciales de la imagen. perímetro y forma pueden ser medidas.y-1) 24 .significa que si los bordes en una imagen pueden ser identificados con exactitud.A(x.y)=A(x. 3. un operador de derivación es sensible a estos cambios y opera como un detector de bordes. Los algoritmos que aquí se mencionan fueron considerados para el desarrollo del proyecto.y) entonces el gradiente es definido como: ∇A(x. ∂A/∂y) Debido a que una imagen no es propiamente una función no puede ser diferenciada de la forma usual como lo es con las funciones reales continuas. El operador resultante ocurre ser el gradiente y si una imagen es pensada como una función de dos variables A(x.

Se presentan las imágenes de una banda clara sobre un fondo oscuro y una banda oscura sobre un fondo claro. La dirección del borde en el mismo píxel es el ángulo que la hipotenusa hace con los ejes.La Figura 3-7 muestra el concepto del operador de derivada. el perfil del nivel de gris a lo largo de una línea de exploración horizontal de la imagen y la primera derivada del perfil. La magnitud del vector gradiente es la longitud de la hipotenusa del triángulo de lados ∇x y ∇y y ésta refleja la fuerza del borde en cualquier píxel dado. Se puede ver en la primera imagen que la derivada del perfil de nivel de gris es positiva en el borde de entrada de la transición y negativa en el borde de salida y cero en las zonas de nivel de gris constante. Figura 3-7 Operador de derivación Se observa en el perfil que un borde está modelado como un cambio suave del nivel de gris. 25 . El vector resultante del calculo del gradiente contiene información acerca de la intensidad del borde en el píxel y cual es su dirección.

Matemáticamente.2 Detector de bordes de Sobel El detector de bordes de Sobel consiste en un par de máscaras de convolución de 3x3 coeficientes mostradas en la Figura 3-8.3.1. Una máscara es simplemente la otra con una rotación de 90°. es decir: Gmag = | (∂A/∂x ) | + | (∂A/∂y) | Y la dirección del borde es aproximadamente: Gdir = atan [(∂A/∂x ) / (∂A/∂y)] 3. Figura 3-8 Máscaras de convolución de Sobel 26 . la respuesta de bordes está dada por: Gmag = [(∂A/∂x )2+ (∂A/∂y)2]1/2 Para fines del cálculo computacional este valor suele calcularse cómo el valor absoluto.

Los operadores de Sobel tienen la ventaja de proporcionar tanto una diferenciación como un efecto de suavizado. utilizando la máscara Gx y y utilizando la máscara Gy. Localización: La distancia entre los píxeles del borde encontrados por el detector y el borde actual debe ser tan pequeña como sea posible Respuesta: El detector no debe identificar múltiples píxeles de borde donde solo existen bordes simples. Entonces se calcula el gradiente en la ubicación del centro de las máscaras en las direcciones x.3. Como las derivadas realzan el ruido. este efecto de suavizado es una característica particularmente atractiva en los operadores de Sobel.3 Detector de bordes de Canny John Canny definió un conjunto de metas para un detector de bordes y describió un método óptimo para adquirirlos. 3. 27 . La suma de estas imágenes da como resultado la imagen gradiente completa. estas metas son: Rango de error: El detector de bordes debe responder solo a bordes y deberá encontrarlos todos. Las derivadas basadas en este operador son: Gx = (z7+2z8+z9) – (z1+2z2+z3) Gy = (z3+2z6+z9) – (z1+2z4+z7) donde las z son los niveles de gris de los píxeles solapados por las máscaras en cualquier posición de la imagen. Así obtendremos por separado los bordes horizontales y verticales.1.

pero una eficiente aproximación es la derivada de una función Gaussiana Para dos dimensiones es G tiene derivadas en ambas direcciones x. 28 . el valor de S es el mismo usado en el paso 2. 2. 1997]. El algoritmo del detector de bordes es el siguiente: 1. y.Canny asumió un borde de paso sujeto a ruido Gaussiano. Crear una máscara para la primera derivada de la función Gaussiana en las direcciones X y Y: Gx y Gy. aún en la presencia de ruido el cual ha sido incorporado en el modelo del borde de una imagen. El problema es identificar un filtro que optimice los tres criterios antes mencionados. Leer la imagen I a ser procesada. La aproximación al filtro óptimo de Canny para la detección de bordes es G’ y así. La desviación estándar S es un parámetro para el detector. 4. El detector de bordes fue asumido para ser un filtro de convolución que suavizara el ruido y localizara los bordes. 3. convolucionando la imagen de entrada con G’ obtenemos una imagen E que tiene los bordes realzados. estos criterios fueron expresados matemáticamente cuya discusión esta fuera de alcance de esta tesis. para mayor información refiérase a [Parker. Crear una máscara Gaussiana G para convolucionar con I. El resultado de la optimización de estos criterios resulta muy complejo para ser resuelto analíticamente. Convolucionar la imagen I con G a lo largo de los renglones para dar la componente X de la imagen Ix y hacia abajo las columnas para dar la componente Y de la imagen Iy.

Cualquier píxel mayor a el umbral Th es marcado como un píxel de borde. Convolucionar la imagen Ix con Gx para dar Ix’. 6. sino también a su rendimiento. después cualquier píxel que esté conectado a este píxel y tenga un valor mayor a Tl es seleccionado como píxel de borde. 29 . 3.y)=(I x’(x. donde los píxeles que no son un máximo local son eliminados.y) como M(x.y)2 + Iy’(x. Por lo general. A pesar de que la imagen original contenga ruido. La explicación más detallada de este proceso puede encontrarse en [Parker. con el objeto de determinar si pertenecen o no a un borde. la componente de I convolucionada con la derivada de la Gaussiana y convolucionar Iy con Gy para dar Iy’. los descriptores deben ser independientes del tamaño. La descripción es un tema central en el diseño de sistemas de visión ya que los descriptores afectan no solo a la complejidad de los algoritmos de reconocimiento. la imagen resultante de aplicar este algoritmo muestra con gran definición los bordes de los objetos más significativos de la escena.y)2) 1/2 El siguiente paso en la detección es la supresión de los no-máximos.4 Descripción El problema de la descripción en la visión consiste en extraer características de un objeto para reconocerlo. Las componentes X y Y deben ser combinadas. La imagen obtenida hasta este momento contiene aún niveles de gris. La magnitud del resultado es calculada en cada píxel (x. Canny sugirió una umbralización usando histéresis. 1997]. la localización y orientación del objeto y deben contener suficiente información de discriminación para distinguir un objeto de otro.5. Este proceso utiliza un umbral mayor Th y uno menor Tl. A continuación se presenta un conjunto de métodos para la descripción de fronteras.

como se muestra en la Figura 3-10a. Es posible establecer códigos de cadena con más direcciones. 30 .1 Códigos de cadena Los códigos de cadena se usan para representar una frontera como un conjunto de segmentos con longitud y dirección especificadas. en primer lugar seleccionamos un tamaño de cuadrícula. La longitud de cada segmento viene dada por la resolución de la cuadrícula y las direcciones las fija el código elegido. le asignaremos un 1 a la celda. codificaremos la frontera entre dos regiones usando los códigos de dirección dados en la Figura 3-9a. mostrándose las celdas con valor 1 en tono oscuro. b) Código de cadena 8-direccional Para obtener el código de cadena de una frontera dada. Finalmente. si una celda incluye más de una cantidad determinada del área interior de la frontera (por lo general un cincuenta por ciento).4. Después. como se ve en la Figura 3-9. le asignaremos un 0.3. Dos bits son suficientes para representar todas las direcciones en el código 4 y se necesitan tres bits para el código 8. esta representación se establece sobre una cuadricula rectangular usando conectividad 4 u 8. en caso contrario. pero los códigos mostrados en la Figura 3-9 son los que se usan más a menudo en la práctica. 1 3 2 1 2 0 4 0 3 5 6 b) 7 a) Figura 3-9 a) Código de cadena 4-direccional. Por lo general. La Figura 3-10b ilustra este proceso.

Figura 3-10 Pasos para obtener el código de cadena El resultado se muestra en la figura 3-11. conectar los extremos de cada segmento mediante una línea recta y asignar a cada línea la dirección más cercana a una de las direcciones permitidas del código de cadena... comenzándo la codificación en la esquina superior izquierda y siguiendo en el sentido de las agujas del reloj... 31 . Figura 3-11 Código de cadena obtenido 0 3 3 0 1 1 0 3 3 3. Un procedimiento alternativo consiste en dividir la frontera en segmentos de igual longitud (esto es. teniendo cada segmento el mismo número de pixeles).

de todas formas. normalizar el código mediante un sencillo procedimiento: dado un código de cadena obtenido comenzando en un punto arbitrario. Es posible.2 Signaturas Una signatura es una representación funcional unidimensional de una frontera. Existen muchas formas de obtener las signaturas. Una de las más sencillas es representar la distancia desde el centro hasta la frontera como una función del ángulo.4. 3. como se muestra en la Figura 3-12. Se puede hacer una normalización de tamaño haciendo que la curva r(θ) tenga un valor máximo de una unidad. Figura 3-12 Dos fronteras y sus correspondientes signaturas de distancia respecto al ángulo La representación de la distancia respecto al ángulo no es la única forma de generar una signatura.Es importante observar que el código de cadena de una frontera depende del punto de inicio. le trataremos como una secuencia circular de números de dirección y redefiniremos el punto de comienzo de forma que la secuencia de números resultante forme un entero de magnitud mínima. Se podría recorrer la frontera representando el ángulo formado por una línea tangente a la frontera y una línea de referencia como una función de posición a lo largo de 32 . Las signaturas creadas mediante este método dependen del tamaño y del punto de comienzo.

i=1.. Por ejemplo.la frontera..2. La signatura que se obtiene. daría información sobre las características básicas de forma. los segmentos horizontales de la curva se corresponderían con líneas rectas debido a que el ángulo tangente sería constante. Una variación de este método es usar la llamada función de densidad de pendiente como signatura. nos enfrentamos con el problema de describirla de forma que nos permita diferenciar entre las signaturas correspondientes a distintas formas de frontera. Una técnica usada a menudo para caracterizar a una signatura es calcular sus momentos. En general sólo se suelen necesitar los primeros momentos para distinguir dos signaturas de formas bien diferenciadas. Supongamos que a es una variable aleatoria discreta que representa las variaciones de amplitud en una signatura y que p(ai).k.. aunque bastante diferente a la curva r(θ). Esta función es un histograma de los valores del ángulo tangente. representa su correspondiente histograma. El momento n-ésimo de a respecto a su media se define como µ (a ) = ∑ (a − m) p(a ) K n n i =1 i i donde m = ∑ ai p (ai ) K i =1 m es el valor medio de a y µ2 es su varianza. Este problema suele ser sencillo ya que tratamos con funciones unidimensionales. donde K es el número de niveles discretos de amplitud.. Una vez que se ha obtenido la signatura. 33 . Como los histogramas nos dan una medida de la concentración de valores. la función de densidad de pendiente respondería fuertemente a secciones de la frontera con ángulos tangentes constantes y tendría profundos valles en las secciones donde se produjeran variaciones rápidas de los ángulos (esquinas u otras inflexiones de forma).

3.4.3 Aproximaciones poligonales

Una frontera digital se puede aproximar con una exactitud arbitraria mediante un polígono. Para una curva cerrada, la aproximación es exacta cuando el número de segmentos del polígono es igual al número de puntos de la frontera de forma que cada par de puntos adyacentes defina un segmento del polígono. En la práctica, el objetivo de la aproximación poligonal es capturar la “esencia” de la forma de la frontera con el menor número posible de segmentos poligonales. Aunque este problema, por lo general, no resulta trivial, y se puede convertir fácilmente en una búsqueda iterativa que consuma un tiempo excesivo, existen gran variedad de técnicas de aproximación poligonal sencillas que se adaptan muy bien para aplicaciones de visión.

3.5 Operaciones Morfológicas

La morfología matemática está basada en la geometría y la forma, Las operaciones morfológicas simplifican las imágenes y preservan las formas principales de los objetos. En visión artificial es frecuente utilizar la morfología para el tratamiento de regiones en el sentido de determinar cómo se pueden cambiar, contar o evaluar.

La morfología puede utilizarse para las siguientes tareas:

El suavizado de los bordes de una región. Esto es útil, por ejemplo, si se necesita mejorar un borde, ya que usando técnicas de segmentación estándar, los bordes se presentan generalmente ruidosos debido tanto al proceso de captura como a los procesos de segmentación apareciendo sobre ellos pequeños valles que pueden suprimirse mediante transformaciones morfológicas.

La separación de determinadas regiones que el proceso de segmentación las presenta unidas.

34

La unión de regiones que han sido separadas durante la segmentación.

3.5.1 Dilatación

La dilatación es una de las dos operaciones básicas en el área de la morfología matemática. Esta es típicamente aplicada a imágenes binarias, pero existen versiones que trabajan sobre imágenes en escala de grises. El efecto básico del operador en una imagen binaria es engrosar gradualmente los bordes de regiones de píxeles de primer plano. Así, las áreas de píxeles de primer plano crecen en tamaño mientras las aberturas en estas regiones se hacen más pequeñas.

El operador de dilatación toma dos muestras de datos como entradas. La primera es la imagen que será dilatada. La segunda es un conjunto de puntos coordenados conocidos como un elemento estructurado (también conocido como kernel o núcleo). Este elemento determina el efecto preciso de la dilatación en la imagen de entrada.

La definición matemática de la dilatación para imágenes binarias es la siguiente:

Suponer que X es un conjunto de coordenadas Euclidianas correspondientes a la imagen binaria de entrada, y que K es el conjunto de coordenadas para el elemento estructurante.

Sea Kx la traslación de K de manera que su origen está en x.

Entonces la dilatación de X por K es simplemente el conjunto de todos los puntos x tal que la intersección de Kx en X no es vacía.

Como un ejemplo de la dilatación, suponemos que el elemento estructurante es una matriz de 3x3, con el origen en el centro, como se muestra en la Figura 3-13. En éste y los

35

siguientes diagramas los píxeles de primer plano son representados por 1 y los píxeles de fondo por 0.

Figura 3-13 Elemento estructurante

Para calcular la dilatación de una imagen binaria por este elemento estructurante, consideraremos cada píxel del fondo en la imagen de entrada a su vez. Para cada píxel de fondo (al que llamaremos el píxel de entrada) sobrepondremos el elemento estructurante en lo alto de la imagen de entrada de tal forma que el origen del elemento estructurante coincida con la posición del píxel de entrada. Si al menos un píxel en el elemento estructurante coincide con un píxel de primer plano en la imagen, entonces el píxel de entrada es situado en primer plano. Si todos los píxeles correspondientes en la imagen son de fondo, el píxel de entrada es dejado en el fondo.

Para este ejemplo, el efecto de esta operación es situar al color del primer plano cualquier píxel de fondo que tenga un píxel del primer plano vecino (asumiendo una conectividad-8). Tales píxeles deberían situarse en los bordes de regiones blancas, y así la conclusión es que las regiones de primer plano crecen y los huecos dentro de una región disminuyen. En la Figura 3-14 podemos apreciar este efecto.

36

37 . Si los píxeles de primer plano y de fondo en el elemento estructurante coinciden exactamente con los píxeles del primer plano y del fondo en la imagen. El elemento estructurante deberá tener siempre un uno en su origen. La operación de adelgazamiento es calculada trasladando el origen del elemento estructurante a cada posible posición en la imagen. Los elementos estructurantes utilizados para el adelgazamiento son del tipo ampliado o extendido.Figura 3-14 Efecto de dilatación usando un elemento estructurante de 3x3 3.2 Adelgazamiento El adelgazamiento es una operación morfológica que es usada para remover píxeles del primer plano seleccionados de imágenes binarias. es decir. de un píxel de ancho sin perder la forma básica de la figura. entonces el píxel de la imagen bajo el origen del elemento estructurante es puesto a cero (fondo). De otra manera no se modifica. el comportamiento de la operación de adelgazamiento es determinado por un elemento estructurante. La salida es una imagen binaria que muestra las figuras formadas por píxeles del primer plano adelgazadas. Como los otros operadores morfológicos.5. y en cada posición comparándolo con los píxeles de la imagen.

y por lo tanto determina la aplicación para la operación de adelgazamiento. usando los elementos estructurales de la figura 3-16. Figura 3-16 Elementos estructurales 38 . Figura 3-15 Ejemplo de adelgazamiento La figura 3-15 muestra un ejemplo de esqueletización por adelgazamiento morfológico de una forma simple.La elección del elemento estructurante determina bajo que situaciones un píxel del primer plano será puesto a cero (fondo).

Existen diferentes representaciones de cómo se almacenan y construyen las asociaciones situación-acción. El nuevo paradigma define un modo de generar comportamiento basado en un acoplamiento directo entre situaciones y acciones. el sistema reacciona de inmediato. 1986]. provocó un giro drástico en cuanto al modo de generar comportamiento. algunos de estos enfoques tratan el control robótico a partir de un modelo conceptual del mundo y una planeación en base a este modelo. Si la situación cambia. Fruto de este replanteamiento nace el enfoque reactivo. quizá liderada por los trabajos de Rodney Brooks [Brooks. para llevar a cabo las acciones pertinentes. algunas de las cuales se describen más adelante. No hay que tener el entorno completamente modelado para emitir una actuación. Esta revolución reactiva.Capítulo IV Arquitecturas de control reactivo 4. simplemente encuentra otra entrada en la asociación. Para finales de los años 80 la falta de flexibilidad del enfoque deliberativo. El funcionamiento principal es un rápido bucle que verifica los valores sensoriales. Esta situación se almacena de algún modo dentro del sistema.1 Introducción Mucho se ha escrito sobre el control de robots móviles. motivó a varios investigadores a replantearse la forma de generar comportamiento. 39 . y los distintos enfoques que se han planteado. busca en la situación que le corresponde y ejecuta la acción recomendada por la asociación. Sin embargo todas repiten el mismo esquema de funcionamiento: periódicamente leen los sensores y consultan la asociación para generar la acción oportuna. Este modo de operar confiere gran agilidad al comportamiento ante cambios en el entorno. Las asociaciones situación-acción permiten reflejar conocimiento temporal con independencia de cómo estas se hayan obtenido.

40 . Esto permite que el diseño del sistema de control reactivo pueda expandir las capacidades del robot añadiendo nuevos comportamientos sin rediseñar o descartar los anteriores. la etología y la psicología han ilustrado varios mecanismos y modelos que podrían ser útiles en la operación de robots. donde la incertidumbre y hostilidad son inherentes. La construcción de modelos abstractos del mundo es un proceso consumidor de tiempo y propenso a errores y esto reduce la potencial exactitud de las acciones del robot. Los comportamiento sirven como la base de construcción para acciones de un robot. 2. El uso de una representación de conocimiento abstracto expíicito es evitada en la generación de respuestas.4. con la actividad sensorial alimentando la información necesaria para satisfacer la aplicación de una respuesta particular de los actuadores. 3. evitando la necesidad de la intervención de una representación del mundo. 4. Los sistemas puramente reactivos reaccionan directamente al mundo como lo han sensado. tales como la neurociencia. Adicionalmente las ciencias biológicas.2 Características Los sistemas de control reactivo tiene las siguientes características: 1. Un comportamiento en estos sistemas consiste típicamente de una simple dualidad sensor-motor. La biología ha proporcionado una prueba que muchas de las tareas que deseamos que realicen los robots son ciertamente factibles. Esto es de particular valor en entornos dinámicos. Estos sistemas son inherentemente modulares desde la perspectiva del diseño de software. Modelos de comportamiento animal sirven como base de estos sistemas. Este incremento de capacidades es útil para la construcción de sistemas cada vez mas complejos.

no es necesario calcular nada en tiempo de ejecución. incluyendo tanto actuaciones como modificación correspondiente del estado interno. Para cada una de ellas la tabla tiene como salida tanto las actuaciones adecuadas como el cambio en esas variables internas si procede.3 Representación Situación-Acción Un modo eficiente de representar asociaciones de este tipo es una sencilla tabla. Para generar comportamiento con esta representación. Debido a que las entradas de los sensores están relacionadas a una situación en la tabla y ésta a su vez con una actuación. Figura 4. La ejecución se centra en leer todas las variables de entrada (percepción) y seguir las indicaciones de la tabla (actuación). basta con leer la recomendación de la tabla. si supone una primera aproximación a la creación de comportamiento. Esta idea sugiere un funcionamiento en bucle infinito: periódicamente se chequean los sensores y las variables internas. Cada situación aparece como una entrada en la tabla y se caracteriza por las entradas sensoriales en ese momento junto con el valor de ciertas variables internas. se empareja la situación actual con la mas parecida en la tabla y se ejecutan las acciones correspondientes que dicta la tabla. una tabla determina la salida adecuada correspondiente a cada una de las situaciones posibles.4. Esto le da mucha 41 .1 Tabla situación-acción Aunque no supone una arquitectura reactiva.

Cada nivel se implementa como una red de autómatas de estados finitos. y de la interacción entre todos ellos sale la acción que se ejecuta en cada momento. como ilustra la Figura 4-2. 4. Existen otras formas de representación y construcción del comportamiento situación-acción para los sistemas de control reactivo. Los niveles funcionan concurrentemente y el comportamiento global observable emerge de la ejecución simultánea de todos ellos. sin embargo. como se menciono anteriormente todas ellas siguen el mismo esquema. que tienen canales de comunicación de ancho de banda bajo para intercambiar señales y 42 . Figura 4-2 Descomposición por niveles de competencia Un nivel de competencia es una especificación informal para una clase de comportamientos de un robot. El control no reside en un único centro de decisión sino que el sistema se compone de varios niveles de competencia ejecutándose en paralelo.velocidad al comportamiento del sistema que puede responder rápidamente a cambios en el entorno.4 Arquitectura de subsunción de Brooks En 1986 Rodney Brooks propuso una descomposición del comportamiento en niveles de competencia.

la navegación deambulante. requiere la anticipación en tiempo de diseño de todas las situaciones en las que se va a encontrar el robot y el cálculo de la respuesta adecuada para todas ellas. Los niveles superiores pueden suprimir las salidas de los inferiores y suplantarles sus entradas. Una limitación de los sistemas reactivos puros es que no saben abordar situaciones nuevas. etc. y en este sentido no aceptan nuevos objetivos. se mantienen implícitos en las asociaciones. Los sistemas reactivos no tienen objetivos explícitos. Si aparece una situación no contemplada en tiempo de diseño el sistema no sabe qué hacer. Comportamientos más sofisticados se generan añadiendo niveles adicionales sobre los ya existentes.5 Limitaciones Además de las ventajas argumentadas y el éxito del paradigma reactivo consiguiendo comportamientos relativamente complicados sobre robots reales. Esto se conoce como subsunción y da nombre a la arquitectura. Esto contrasta con los sistemas deliberativos que enfrentados a una situación novedosa. son capaces de utilizar su deliberación para abordarla con éxito. El aprendizaje conlleva un nuevo cálculo de la tabla de asociaciones. Una vez calculada la acción oportuna. 43 . Los niveles inferiores proporcionan comportamientos básicos como evitar obstáculos. pero desde el punto de vista de diseño supone la traslación de todos los problemas de selección de acción a la etapa de construcción del sistema. 4. Por ejemplo. en tiempo de ejecución sólo hay que consultar la asociada con la situación actual.pequeñas variables entre ellos. salvo que se redefinan las asociaciones. este enfoque también presenta numerosos inconvenientes. La ejecución en un sistema reactivo es rápida y ágil.

para conseguir éste objetivo podemos identificar las siguientes tareas a realizar en el sistema: • • • • Adquirir imágenes. Localizar el objeto guía. con la finalidad de poder integrar más módulos de comportamiento que aumenten la autonomía del robot.Capítulo V Diseño del sistema 5. 44 . obteniendo así un sistema más robusto. es el reconocimiento del objeto guía a través de visión proporcionada por una cámara. Identificar el objeto guía. flexible y escalable.1 Introducción La arquitectura del sistema se ha diseñado en base al objetivo de crear un sistema modular.2 Arquitectura El objetivo principal del sistema. Dirigir al robot hacia el guía. Otra tarea que debe realizar el robot es la detección de obstáculos por lo que en base a estas tareas definimos la arquitectura del sistema creando módulos encargados para la realización de cada una de ellas. 5.

En la capa inferior (nivel de competencia 0 seguir objeto) el inicio del proceso comienza por el módulo de Adquisición de imágenes. hasta el módulo encargado del movimiento del robot en la dirección determinada por el bloque de localización. esta arquitectura del sistema se acopla al diseño de una arquitectura reactiva como la de Brooks descrita en el capítulo anterior. El módulo funcional realiza el control de los sónares del robot. La capa superior en la arquitectura (nivel de competencia 1 detectar obstáculos) se encarga de la detección de obstáculos.Control Sónares DETECTAR OBSTACULOS Adquisición de imágenes Identificar objeto Localizar objeto Controlador del Robot SEGUIR OBJETO SENSORES Figura 5-1 Arquitectura del sistema ACTUADORES La figura 5-1 muestra la relación y el flujo de control entre los diferentes módulos en cada capa. 45 . para evitar la colisión del robot con algún objeto o persona. quien pasa el control a los módulos de la derecha que realizan la identificación y localización del objeto en la imagen respectivamente.

3.3 Módulos funcionales 5.1 Capa Seguir Objeto Cada bloque del sistema desempeña funciones específicas para cumplir con su objetivo.5. El módulo de Adquisición de imágenes realiza las siguientes funciones: • • • Reconocimiento y manejo del hardware Extracción de cuadros de video Visualización del video en la interfaz grafica El módulo de identificar objeto aplica a la imagen filtros y técnicas del procesamiento digital de imágenes para discriminar objetos en la escena y aislar al objeto guía. Las funciones realizadas por este módulo son las siguientes: • • • Segmentación de la imagen Mejora de la imagen para su interpretación Detección del guía La siguiente imagen muestra los bloques internos DILATACION DETECCIÓN SEGMENTACION ADELGAZAMIENTO Figura 5-2 Bloques internos del módulo de identificar objeto 46 .

4 Selección de Algoritmos Una de las partes críticas del proyecto fue la elección de los algoritmos que serían implementados para el módulo de Identificación. La elección de éstos estuvo ligada por el objeto guía que se debería identificar. El objeto guía fue elegido para que fuese fácilmente discriminable de otras figuras que pudieran encontrarse en cualquier escenario.3. La salida de datos de está capa puede suprimir los datos de la capa superior. pues pondría en riesgo la integridad del robot si al seguir el objeto guía se encuentra un obstáculo.2 Capa Detectar Obstáculos En esta capa se realiza la comprobación de los sónares del robot con el finalidad de detectar objetos cercanos e impedir el movimiento del mismo. ya que se pretende que el robot pueda realizar el procedimiento de forma adecuada en un ambiente no 47 . Las funciones que realiza son: • • • Cálculo del área del objeto Cálculo del desplazamiento Envío de comandos al controlador del robot Por último tenemos el módulo Controlador del robot que realiza el movimiento del robot directamente. Las funciones que este realiza son: • • • Conectar / Desconectar Avanzar / Retroceder Girar 5. 5.El módulo de localizar objeto es encargado de determinar la posición del objeto guía en la imagen y enviar la orden precisa al controlador del robot para seguir al objeto manteniéndolo en el campo de visión .

es decir. Por esta razón la figura geométrica elegida que proporciona estas dos características es un círculo. éste debe ser aislado en una imagen y enviado al bloque de localización. Se aplica un filtro que enlace segmentos de líneas abiertos en un espacio considerable (2 ó 3 píxeles). buscamos saber si el punto inicial del recorrido coincide con el punto final. Si se trata de una figura cerrada. Se realiza el seguimiento de los bordes en la imagen verificando si se trata de una figura cerrada. los siguientes pasos muestran las tareas necesarias para éste proceso: 1. se aplica un algoritmo que determine si se trata de un círculo. Podemos entonces determinar los algoritmos necesarios para la implementación del proceso de identificación. 4. Se aplica un proceso de segmentación de la imagen basada en la detección de bordes. 2.estructurado. como son: • • • • Implementación de un detector de bordes: Detector de bordes de Canny Implementación de un filtro dilatador Algoritmo de seguimiento de bordes Algoritmo de identificación: Signatura 48 . 3. De forma más concreta. Si el proceso anterior determinó que la figura es un círculo. 5. La solución propuesta para la identificación del círculo es su reconocimiento a partir de su forma. el guía es un círculo de color blanco sobre un fondo negro que proporciona un mayor contraste con el escenario.

IGU + conectar() + com enz ar() + detener() ca m a ra ~ captura() ca nny Loca liza controlCe ntra l Ide ntifica + aplica() + aplica() robot + estado + + + + + + c onec taRobot() c onec taS im ulador() adelante() atras () izquierda() derecha() Figura 5-3 Diagrama de clases 49 . Con la finalidad de crear un sistema fácilmente estructurado se realizó un diseño del software empleando el Lenguaje de Modelado Unificado-UML.5 Diagrama de Clases El siguiente diagrama (Figura 5-3) muestra las clases que conforman el sistema. A continuación se muestran y describen los diagramas del UML empleados para el diseño del sistema.La elección de los algoritmos implementados para la identificación del círculo son una aportación a este proceso con la finalidad de poder evaluar la eficacia del reconocimiento. así como las relaciones entre ellas y sus principales métodos. 5.

Figura 5. 50 .5. primeramente indicando que se desea realizar una conexión con el robot.6 Diagrama de Secuencias El siguiente diagrama (Figura 5-4) muestra la interacción entre los objetos software involucrados y los mensajes enviados a través del tiempo.4 Diagrama de secuencia El usuario interacciona con el sistema a través de la Interfaz Grafica de Usuario (IGU). así la IGU envía la petición al sistema de control central y éste llama al método conectar() de la clase robot.

La clase identifica devuelve una imagen con el objeto guía aislado. comenzando por la captura de una imagen. la cual es un parámetro para el objeto identifica. éste es encargado de llamar a cada uno de los objetos que realizarán los procesos de detección. El diagrama muestra el inicio del proceso de seguimiento. localización y movimientos del robot. y ésta es pasada como parámetro a la clase localiza para determinar la posición del guía y enviar el comando adecuado a la clase robot que ejecuta el movimiento. 51 .Posteriormente el usuario inicia el proceso de seguimiento nuevamente a través de la IGU. la petición es recibida por control central.

la configuración del formato de la imagen y de la resolución de 160x120. //Verifica si se encontró algún dispositivo if (!dispositivos.isEmpty()) 52 .2 Adquisición de imágenes Para este bloque se hace usó de la API Java Media Framework con la que se realizan las funciones descritas en el capítulo anterior que son: el manejo del hardware.YUV)). En seguida se describe la implementación de cada uno de los bloques del sistema de control comenzando con la capa inferior mostrada en la arquitectura del sistema del capítulo anterior. 6. El siguiente código muestra el procedimiento de detección de la cámara. //Obtiene una lista de los dispositivos multimedia conectados a la PC Vector dispositivos = CaptureDeviceManager. la visualización del video y la extracción de cuadros del video para el procesamiento.1 Introducción La implementación del sistema se realizó en el lenguaje de programación Java para el procesamiento de imágenes y Visual C++ para el bloque de control directo con el robot utilizando la librería PAI mencionada en el capítulo 2 y el uso de la API Java Media Framework para el manejo del dispositivo de video instalado (cámara).getDeviceList(new VideoFormat(VideoFormat.Capítulo VI Implementación del sistema 6.

getLocator()).close(). FrameGrabbingControl"). // Inicia la reproducción 53 .jPanel1. dimensión de la imagen. format = new VideoFormat("RGB". } //crea un DataSource di = (CaptureDeviceInfo)dispositivos.0f).jTextArea1. new Dimension(160. player. } catch (IOException e) {} catch (NoPlayerException e) {} catch (CannotRealizeException e) {} if (player!=null) { //añade a la interfaz de usuario el video frame. byte[].exit(0).createDataSource(di.firstElement().append("No hay ningun dospisitivo conectado\n"). } catch (NoDataSourceException e) {} catch (IOException e) {} //Configura el formato de video. 57500. } //configura un objeto “fgc” para extraer frames del video a través del player fgc = (FrameGrabbingControl)player.getControl("javax.getVisualComponent()).control. try { ds = Manager. System.120).media. 30.{ } else { frame. cuadros por segundo (para la //reproducción) y el tipo datos del buffer.class.add(player.createRealizedPlayer(ds). //crea un objeto Player utilizado para visualizar el video en la interfaz de usuario try { player = Manager.

getLength(). el tipo de datos en el que esta almacenada la información de la imagen.k++) { r=(int)(Imdata[(k*3)+2])&0xff. } procesa. como son las dimensiones.k<(buf. prom = (int) ((r + g + b)/3). g=(int)(Imdata[(k*3)+1])&0xff.getData(). //Extracción de cuadros de video y conversión a escala de grises buf = fgc. realiza esta conversión además de 54 .start(). Imdata=(byte[])buf. es decir.player.getLength()/3].getLength()/3)-1. Imdata=new byte[buf.ejecuta(data. entre otros. la longitud del “buffer”. uno para cada valor de la intensidad del rojo.getLength()/3)-1-k]=prom<<16|prom<<8 |prom|(0xff<<24). Estos datos de la imagen deben ser almacenados en un arreglo para su manipulación y son enviados al módulo de identificación. para el manejo de los datos. el verde y el azul. para cada píxel de la imagen se tienen tres bytes.getLength()]. En el arreglo están almacenados los valores para cada punto de la imagen en cada canal. son guardados en un arreglo de enteros. La extracción de los cuadros de video y el procesamiento se realiza independientemente del proceso de visualización en la interfaz.n++). Por simplicidad. El ciclo. b=(int)(Imdata[(k*3)])&0xff. El buffer almacena un arreglo de tipo byte. data[(buf. por lo que es necesaria la creación de un hilo que atienda la extracción de los cuadros en un intervalo de tiempo. La extracción se lleva a cabo haciendo uso del método grabFrame del objeto fgc que regresa un “buffer” con información del cuadro capturado. for(int k=0. de longitud buf. en el fragmento de código anterior.grabFrame(). data=new int[buf.

6. ori=new int[ancho * alto]. int ancho.smx). this. asignando las intensidades de los canales RGB a variables del mismo nombre.int lenArr. calculando el promedio y asignando el valor al arreglo de enteros realizando los corrimientos necesarios. dxy_separable_convolucion(dsmx. se llama al método ejecuta del objeto procesa que está encargada de aplicar los filtros necesarios a la matriz para extraer al objeto guía (círculo) de la imagen.pix=pix.float sigma) { this.1. 55 . smx=new float[ancho * alto]. this. smy=new float[ancho * alto]. canny(int[] pix. mag=new int[ancho * alto]. Como se observa en el diagrama de clases (Figura 5-3) se creó una clase para este proceso. las líneas de código muestran el constructor de la clase que llama a los métodos necesarios que integran el algoritmo.0. this. dxy_separable_convolucion(dsmy.pix=new int[lenArr]. dsmx=new float[ancho * alto].smy).3 Detección de bordes Como se mencionó en el capítulo anterior. convolucion_separable().realizar la conversión de la imagen en color a escala de grises.ImAncho=ancho. dsmy=new float[ancho * alto]. el reconocimiento se inicia a partir de la extracción de bordes de la imagen capturada aplicando el algoritmo de Canny descrito en el capítulo 3.int alto.sigma=sigma.ImAlto=alto. gauMasks(). this. Al terminar la conversión.

La primera llamada en el constructor es a un método que crea la máscara de convolución Gaussiana.0. dsmy=null. Al igual que en el paso anterior se realiza para ambas direcciones.ori=null. mag=null. La llamada al método convolución_separable() aplica el suavizado Gaussiano a la imagen.smx=null. haciendo un llamado al método dxy_separable_convolucion(). hysteresis(high. donde depositará los resultados 56 . } El constructor recibe como parámetros la imagen a procesar (pix). a) b) Figura 6-1 a) Suavizado Gaussiano en X b) Suavizado Gaussiano en Y El siguiente paso es aplicar la operación de convolución dichas imágenes con la derivada de la función Gaussiana (). la longitud del arreglo. dsmx=null. smy=null.pix.low. que recibe los parámetros: • Matriz. la figura 6-1 muestra las imágenes después de este paso con sigma=1.mag).dsmy). sup_nomax(dsmx. ImMag(). las dimensiones de la imagen y el parámetro sigma que determina el nivel del suavizado Gaussiano implícito en el algoritmo.

que determina la dirección en que se aplicará la derivada 0 para Y y 1 para X Imagen.• • Valor entero. Figura 6-3 Magnitud de las imágenes La Figura 6-4 muestra el resultado de los dos últimos pasos del algoritmo de Canny que son: la supresión de no-máximos y el proceso de histéresis. suavizada en el proceso anterior La figura 6-2 muestra las imágenes resultantes Figura 6-2 Convolución con la derivada de la función Gaussiana en X y Y respectivamente En este punto ambas imágenes son combinadas con el método ImMag() que calcula la magnitud obteniendo el resultado de la Figura 6-3. 57 .

y debido a que el círculo a reconocer es una figura cerrada se aplica una dilatación que cierre huecos de entre 2 y 3 píxeles con la finalidad de que en el siguiente paso se discriminen los objetos que no sean una figura cerrada.int Y) 58 . } public int conectados(int X.i.j.j<iniAlto-1.4 Dilatación El algoritmo de dilatación está implementado en la clase identifica y es llamado inmediatamente después de la detección de bordes en la clase controlCentral. else setValue(pix1.j)>=1) setValue(pix1. 6.a) b) Figura 6-4 a)supresión de no-máximos b)Histéresis Posterior a la extracción de bordes.pixel(pix. } copia(pix.pix1). las líneas de código mostradas a continuación realizan la dilatación de la imagen.j. es posible que existan huecos entre líneas.i<iniAncho-1.i.i.j)).j++) { if (conectados(i. public void dilata() { for(int i=1.i++) for(int j=1.255).

if (pixel(pix.X+1. if (pixel(pix.{ int conec. if (pixel(pix.X.Y+1)==255) conec=conec+1.X+1.Y)==255) conec=conec+1.X-1.Y+1)==255) conec=conec+1.Y)==255) conec=conec+1.Y-1)==255) conec=conec+1.X. En la figura 6-5 se observa una imagen que contiene huecos en algunas líneas y la imagen dilatada que ha cerrado estos huecos. if (pixel(pix. if (pixel(pix.X-1. conec=0.X+1.Y+1)==255) conec=conec+1. } La dilatación logra unir huecos existentes entre líneas. éste no ha sido cerrado debido a que la longitud de la grieta entre las 2 líneas más cercanas es mayor a 3 píxeles. Esta situación podría resolverse aplicando la 59 . if (pixel(pix. a) b) Figura 6-5 a)Imagen con aberturas entre líneas b) Imagen dilatada Podemos observar en la imagen a) los huecos enmarcados por círculos rojos y en la imagen b) el proceso de dilatación ha cerrado estos huecos.Y-1)==255) conec=conec+1.X-1. return conec.Y-1)==255 ) conec=conec+1. a excepción del punto marcado en la parte inferior izquierda. if (pixel(pix. if (pixel(pix.

6 Algoritmo de seguimiento de bordes El siguiente algoritmo se implementó para el seguimiento de los bordes en la imagen. 60 . de izquierda a derecha y de arriba abajo. 6. La secuencia de pasos es la siguiente: 1. por consiguiente después de la dilatación es necesario realizar un adelgazamiento. Donde S es el conjunto de puntos del borde.5 Adelgazamiento Para poder realizar el seguimiento de los bordes de las figuras y determinar si es una figura con un perímetro cerrado es necesario que los bordes mantengan un grosor de un píxel. el circulo presenta huecos de a lo mas 3 píxeles por lo que no es necesario cerrar huecos más grandes. Figura 6-6 Imagen adelgazada después de la dilatación 6. es decir. El resultado es una imagen como la que se observa a continuación (Figura 6-6). Encontrar el píxel de comienzo s que es un elemento de S en la figura usando un barrido sistemático. pero para las pruebas realizadas.dilatación nuevamente.

void sigueBorde(int[] p1. i < iniAncho. Así solo aquellas figuras que cumplan con la condición c=s pasaran a la fase de reconocimiento del círculo.size()<30)//si la figura tiene una longitud menor a 30 pixeles es eliminada de la imagen { for (int x=0.2. j < iniAlto. 3.n2.int[] p2) { for(int i = 1. Hacer c= ni y b= ni-1 5. Sea el píxel actual en el recorrido denotado por c. Sean los 8 vecinos de c comenzado con b en sentido de las manecillas del reloj n1. if (puntos..size(). es decir. el seguimiento del borde se realiza como se describió en el algoritmo anterior. j. j) == 255)){ //aplica el algoritmo de seguimiento del borde getBound(i.x<puntos. j++) { if((pixel(p1..i. i++) for(int j = 1. En el caso en que en el recorrido del borde c sea igual a c-1.. Hacer c=s y sea b el píxel vecino de conectividad 4 a la izquierda que no pertenece a un píxel del borde. por lo que es eliminada de la imagen y se inicia el proceso con el siguiente punto de borde encontrado.p1). Repetir los pasos 3 y 4 hasta que c=s La imagen comienza a recorrerse a partir de la esquina superior izquierda y se encuentra el primer punto de borde que pertenece alguna figura. se ha detectado que el nuevo punto ya ha sido recorrido en un paso anterior. nos indica que es el fin de la figura y se trata de una figura abierta.x++) { 61 . encontrar ni para el primer i que esta en S n1 b n7 n2 c n6 n3 n4 n5 4.b8.

setValue(p1.elementAt(x). cerrado=false.y. abierto=false.x.0). cerrado=false. abierto=false.x.y. setValue(p1.p=(point)puntos.//Determina si la figura encontrada es un circulo for (int x=0.0).removeAllElements().p.elementAt(x).size(). } puntos.j=1. i=1. abierto=false.x.x++) { p=(point)puntos.x++) { p=(point)puntos. } 62 .0).y.removeAllElements().y. abierto=false. } puntos.p. i=1.0).j=1.x<puntos.x<puntos. i=1.p.p. setValue(p1. } cerrado=false.x. } if (cerrado) //si la figura es cerrada { identifica().elementAt(x).size().p. else setValue(p2. } if (abierto)//si la figura es abierta se elimina de la imagen { for (int x=0.p. } circulo=false.removeAllElements().p. puntos.x.j=1.y. if (circulo) setValue(p2.255).p. cerrado=false.p.p.

Ésta distancia se calcula de la siguiente forma dis = (h − x) 2 + (k − y ) 2 Se encuentra el punto más lejano. ésta es analizada para determinar si se trata del círculo guía. Tomado en cuenta que en un círculo la distancia del centro a cualquier punto de la circunferencia es la misma para todos los puntos. Para determinar esto se encuentra primeramente un punto del borde y se calcula la distancia hacia todos los otros puntos de la figura. El procedimiento consiste en hallar el centro relativo del objeto.7 Algoritmo de identificación del círculo Una vez que se ha encontrado una figura cerrada. El algoritmo utilizado se basa en la idea de la signatura explicada en el capítulo 3. así el punto medio de la recta que uno a los dos puntos más lejanos del borde será el centro de la figura (al menos cuando se trata de un círculo). debemos ahora comprobar que se trata de un círculo. Figura 6-7 Centro del objeto Ya que hemos localizado el centro de la figura.6. 63 . calculamos esas distancias.

éste puede aparecer en la imagen ligeramente deformado. La figura 6-8 muestra una grafica de la distancia del centro hacia cada punto del borde. Considerando que la figura detectada no define exactamente un círculo. Figura6-8 Gráfica de la distancia del centro a los puntos del borde La línea roja muestra el valor promedio de la distancia del centro al borde. es decir. alejarse. El valor establecido ha sido del 97 por ciento. la línea en negro muestra las distancias del centro hacia todos los puntos. Observamos que hay puntos mayores y menores a la línea promedio. Por lo tanto. así que podemos establecer un intervalo en el que deberán estar estos valores. con lo que se logra una detección bastante precisa. en esta fase se determina la posición del círculo en la imagen para poder dirigir el robot hacia el guía. pero hasta cierto punto se mantienen constantes. debido a la orientación del guía. es decir. se decidirá si el robot debe acercarse.8 Localización del objeto En la etapa anterior hemos obtenido una imagen que contiene únicamente un círculo. muy aproximados al valor promedio. girar a la izquierda o a la 64 . cualquier figura que exprese una grafica parecida a la anterior en la que sus valores oscilen entre más tres y menos tres puntos corresponderá a un círculo. Podemos estipular un criterio de aproximación a un círculo en base al porcentaje de puntos que cumplen la condición del párrafo anterior.Debido a que una imagen representa una función con valores discretos la distancia hacia todos los puntos no es exactamente la misma. 6.

j-1). El siguiente fragmento de código muestra la función implementada public void calculaArea(int i. boundaryFill(i.i.int j) { if(pixel(pix1. boundaryFill(i.j) == 0) { area++. Primeramente consideramos los casos en los que el objeto se encuentra alejado o demasiado cerca del robot.5%. boundaryFill(i-1. no se toma en cuenta los estados anteriores del robot o del guía. El robot se mantendrá estático frente al guía cuando el área del círculo se encuentre en un intervalo definido por el valor medio del área máxima y el valor medio del área más una constante. calculamos el área del círculo en la imagen resultante del proceso anterior. El valor máximo del área que puede tomar el círculo es del 40% del total de píxeles en la imagen y el valor mínimo es del 0. Esta decisión se toma únicamente en base a la imagen actual.j+1).derecha. El área del círculo se determina en base al número de píxeles contenidos dentro del círculo. Para determinar esto. se pretende situar al robot a una distancia considerable en la que se mantenga al objeto cercano al robot.j). boundaryFill(i+1.j). puesto que se pretende un comportamiento reactivo. } } Los parámetros con los que es llamada la función son el centro del círculo que a partir de ese punto se lleva a cabo el conteo de los píxeles interiores. 65 . Se implementó un algoritmo recursivo que calcula este valor.

Los procedimientos de conexión son llevados a cabo mediante el llamado a la función paiRobotStartup(param1. es decir rotará en el mismo lugar en que se encuentra moviendo ambas ruedas. es decir. derecha o en la sección central y con esta información se envía la orden de rotación en 2 grados al robot hacia la dirección adecuada. en caso contrario el robot se detendrá.Para determinar la dirección de rotación del robot hacia el guía. El robot rota sobre su eje. en la parte izquierda. con la ayuda de la librería PAI mencionada en el capítulo 2 haciendo uso de las funciones de conexión (con el robot o el simulador Pioneer).1) donde los parámetros param1 y param2 definen si la conexión se realizará con el robot o con el simulador.1. desplazamiento y rotación del robot así como la manipulación de los sónares para la detección de obstáculos. se dividió el área de la imagen en tres secciones verticales. es decir. param2. al detectar al objeto guía no se determina una posición absoluta a alcanzar sino que el robot se moverá a una velocidad constante hacia el guía mientras el sistema detecte el círculo.9 Controlador del robot La implementación del módulo de control se realizó en el lenguaje de programación visual C++. en base a estas secciones se determina en cual de estas se encuentra el centro del circulo. 6. Los grados de rotación son un valor fijo hacia la dirección determinada por el módulo de localización. 66 . Para realizar el desplazamiento y con la finalidad de obtener un movimiento “suave” al momento de desplazar al robot el movimiento se realiza por velocidad. En caso de que el objeto se encuentre en el sección central el robot permanecerá estático.

} } Como se mencionó en el capitulo anterior el sistema tiene dos metas a alcanzar que son el seguimiento del objeto guía y la detección de obstáculos para evitar situaciones de riesgo. Las siguientes líneas de código muestran la clase que implementa el llamado a las rutinas para el controlador del robot class controlador static public static public static public static public static public static public static public static public static public static public { native native native native native native native native native native void conectaSim(). dado que se deben evitar las situaciones de riesgo. void desconecta(). void moverDistancia(int dist).loadLibrary("controlador").Este módulo de control esta compilado como una librería DLL y es manipulada desde Java mediante el uso de los métodos nativos de Java (JNI-Java Native Interface). void setVelocidad(float ang). void rotarHeading(float ang). void moverVelocidad(int vel). por lo que en este módulo se realiza la verificación de los sónares para detectar obstáculos en el entorno del robot.int dist).int b. 67 . int Obstaculo(int a. en consecuencia el robot recibirá la orden de paro. que permiten la inclusión de librerías escritas en un lenguaje distinto a través de llamadas a métodos en el lenguaje Java. void conectaRob(). static { System. void setRotVelocidad(int vel). las salidas de la tarea de detección de obstáculos (mostrada en la arquitectura) suprimirá la salida de la tarea seguir objeto en caso de que se haya detectado un obstáculo a una cierta distancia. void girar(float ang).

6. así como mensajes sobre la conexión con el robot o el simulador.10 Interfaz de Usuario La interfaz de usuario proporciona cuatro botones de control que permiten la conexión con el simulador o el robot.Dada la distribución de los sónares se valida la detección de obstáculos en un rango de 0º a 180º de la zona frontal del robot. La imagen siguiente muestra la interfaz grafica de usuario y señala cada una de sus partes 68 . este se encuentra ejecutándose en un hilo de control independiente al procesamiento de detección. Entre estos mensajes se encuentran la acción que realiza el robot en consecuencia al proceso de detección del objeto guía o de la presencia de algún obstáculo. Existe un área de información en la que se despliega en todo momento las acciones que se llevan a cabo por el usuario y/o por el sistema cuando este se encuentra en el proceso de control autónomo. el inicio del sistema de control y la posibilidad de extraer cuadros de la imagen de forma manual por el usuario. También se muestra el video activo capturado por la cámara.

69 . en esta ventana el usuario puede observar que el sistema ha detectado el guía cuando se muestren líneas que parten del objeto detectado hacia los extremos izquierdo. en este caso una retícula de color rojo encerrará al objeto. También se proporciona de esta manera información cuando el objeto se encuentra centrado. es decir.Figura 6-9 Interfaz Gráfica de Usuario Alternativamente se pueden observar las imágenes procesadas en una ventana independiente donde se muestra información grafica de la detección del círculo. derecho e inferior de la imagen. Se observa esta ventana en la Figura 6-10.

se observa el comportamiento del robot en un ambiente virtual dirigiendo al robot entre pasillos y puertas guiado por el círculo. Figura 6-11 Ejemplo con el simulador de navegación guiada por el círculo 70 .Figura 6-10 Interfaz Gráfica de Usuario Con la ayuda del simulador Pioneer. Se muestra un ejemplo en la Figura 6-11.

A diferencia de algoritmos de seguimiento como el de correlación en el que el procesamiento se lleva a cabo únicamente sobre una región “pequeña” de la imagen. A pesar de las limitaciones de la cámara utilizada. realiza la tarea de navegación de manera autónoma dirigido por el objeto guía en escenarios normales. se alcanzó un número aceptable de procesamiento de cuadros por segundo (13 fps). Primeramente podemos mencionar la eficacia del procesamiento de imágenes. El robot es capaz de manifestar el comportamiento esperado de forma adecuada en un ambiente no estructurado. que el sistema es capaz de detectar un objeto guía con un radio de 8 cm a una distancia de hasta 3. la distancia máxima de detección esta en función del tamaño del objeto. es decir. empleando tarjetas de adquisición de imágenes desde una cámara analógica de mayor velocidad de muestreo.Resultados y Conclusiones Después de llevar a cabo la implementación completa del sistema. en este proyecto se aplica el procesamiento sobre toda la imagen debido a la naturaleza del objetivo planteado de identificación de un objeto característico en toda la imagen. cuyo desempeño influye directamente en todo el sistema. se llevó a acabo la etapa de pruebas con la finalidad de evaluar el desempeño del sistema en diferentes condiciones y configuraciones del sistema.5m. Como puede verse. Con las pruebas realizadas se determinó. Esto limita a procesar imágenes de 160 x 120 píxeles para poder alcanzar un número aceptable para un buen desempeño. a mayor tamaño mayor distancia. ya que el procesamiento digital de imágenes es una tarea que consume gran tiempo de ejecución debido al número de datos que deben ser procesados. 71 . Este número podría incrementarse con hardware de mayor velocidad. y para cumplir con el enfoque reactivo de la arquitectura el tiempo de procesamiento debía ser optimizado.

Es decir. éste es un factor importante que afecta a muchos algoritmos de seguimiento como la correlación. o la adaptación de una cámara infrarroja que le permita realizar su tarea en ausencia de luz detectando objetos que emitan calor. Reconocimiento de otras formas. 72 . Este tipo de robots puede ser adaptado con una variedad de dispositivos que le permitan mayor funcionalidad como la adaptación de pinzas para sostener objetos. Algunas de ellas podrían ser • • La búsqueda autónoma del objeto guía.Trabajos Futuros En base a la arquitectura desarrollada es posible agregar capas que ejecuten alguna otra tarea ampliando así la autonomía del robot. incluso la identificación de personas. Referente al proceso de detección como trabajos futuros se pueden desarrollar algoritmos para el control de la intensidad de luz en las imágenes que afectan la detección del objeto guía. que el robot deambule por su entorno en buscando su objetivo.

IEEE Journal of Robotics and Automation.10. Manipuladores y robots móviles. November 2002. Gonzalez. ActivMedia Robotics. Alfaomega. Wiley. R. Arkin. 1999] ActivMedia. Robótica. ActivMedia Robotics Pioneer 2/PeopleBot Operations Manual v11. Technical Report version 1. 1998] ActivMedia. ActivMedia Robotics. ActivMedia Robotics. Visión por Computador. Technical Report version 6. Brooks. PAI Programmer’s Manual. March 1998. ActivMedia Robotics August. v4. [Parker. Digital Image Processing. 1997] J. 2002] Gonzalo Pajares.Bibliografía [ActivMedia. ARIA reference manual.2001. Pioneer 2 Mobile Robot – Operations Manual. [ActivMedia.1. 1999. [Gonzales y Woods. [ActivMedia. 1992] R. 2000] Ronald C. [Arkin. Behavior-Based Robotics. The MIT Press. Parker. [ActivMedia. March 1986.2. 2000. 2002] ActivMedia. [Brooks. 1986] Rodney A. 1999] ActivMedia. 2001] Anibal Ollero Baturone. September 2002. Woods. 73 . [Pajares.E.2002. [Baturone. 2002] ActivMedia. ActivMedia Robotics. Algorithms for Image Processing and Computer Vision. 1992. Addison-Wesley.C. 2(1):14–23. [ActivMedia. Saphira operations and programming manual. Alfaomega-Marcombo. August 1999.1997. R. A robust layered control system for a mobile robot.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->