Laura Lopez MSc Thesis

CAPITULO

UNIVERSIDAD DE GUADALAJARA Centro Universitario de Ciencias Exactas e Ingenierías Departamento de Electrónica Maestría en Ciencias en Ingeniería Electrónica y Computación

Tesis:

“Algoritmos de control visual de robot sobre plataformas móviles de procesamiento” Que para obtener el grado de Maestro en Ciencias en Ingeniería Electrónica y Computación

Presenta:

Laura López López Director:

Dr. Marco Antonio Pérez Cisneros Co-Director:

Mtro. Jorge Fausto Hernández Andrade

Guadalajara, Jalisco 27 de febrero del 2012 1

CAPITULO Aceptación de protocolo

2

CAPITULO Oficio de director y co-director

3

CAPITULO

Agradecimientos A mis padres Ignacio López Cerna y Lilia López Arambula por su constante apoyo, motivación y cariño para continuar mis estudios y superarme día a día. Al Dr. Marco Antonio Pérez Cisneros por su invaluable ayuda al compartir sus conocimientos y amistad guiándome durante el transcurso de la maestría y la realización de esta tesis. Al Mtro. Jorge Fausto Hernández Andrade por su amistad y apoyo constante en la investigación y la culminación de esta tesis. Al Dr. Erik Cuevas Jiménez, Dr. Daniel Zaldívar y compañeros del IRSI por su ayuda y amistad. Gracias a todas aquellas personas que han estado a mi lado motivándome y compartiendo en todo momento mis logros.

4

CAPITULO

Resumen En esta tesis se realizo una investigación de las principales plataformas para la programación de dispositivos móviles disponibles actualmente en el mercado, considerando sus características tanto de hardware como de software, con el objetivo de elegir una prestación conveniente para el desarrollo de sistemas robóticos de control visual. Dentro de este proceso, de forma natural, deben estudiarse también las distintas metodologías de programación asociadas con cada plataforma. El estudio se focaliza después en la plataforma de Windows Phone 7. Este trabajo desarrolla tres etapas importantes. La primera permite profundizar sobre cada una de las herramientas y su manejo para el desarrollo de distintas aplicaciones de visión computacional. La segunda etapa establece las bases de la visión por computadora con el objetivo de diseñar aplicaciones basadas en el sistema operativo Windows Phone 7. La tercera etapa es el desarrollo minucioso y la implementación de aplicaciones visuales como son el algoritmo de erosión, de dilatación y operador sobel, cuyos resultados se documentan en esta tesis. Esta tesis ofrece como conclusión una revisión de los resultados más relevantes que se obtuvieron durante el desarrollo de las aplicaciones para plataformas móviles que se desarrollaron en la plataforma de Windows Phone7.

5

CAPITULO

CONTENIDO Agradecimientos .............................................................................................................................. 4 Resumen ............................................................................................................................................ 5 Lista de Figuras................................................................................................................................. 8 Lista de Tablas ................................................................................................................................ 10 Capítulo I. INTRODUCCIÓN ................................................................................................... 112 Justificación ................................................................................................................................. 13 Hipótesis...................................................................................................................................... 13 Objetivos...................................................................................................................................... 13 Metas del trabajo ........................................................................................................................ 14 Contribuciones ........................................................................................................................... 14 Estructura del trabajo .............................................................................................................. 144 CAPITULO 2 ANTECEDENTES................................................................................................ 16 Evolución de las Computadoras ............................................................................................. 17 Evolución de los dispositivos móviles .................................................................................... 18 CAPITULO 3 SISTEMAS OPERATIVOS ................................................................................. 191 Lenguajes de programación para dispositivos móviles .................................................... 266 CAPITULO 4 VISION POR COMPUTADORA ...................................................................... 333 Binarización mediante detección de umbral ........................................................................ 344 Flujo Óptico............................................................................................................................... 355 Erosión ....................................................................................................................................... 377 Dilatación .................................................................................................................................. 388 Operador de Sobel ..................................................................................................................... 40 CAPITULO 5 PROBLEMÁTICA A RESOLVER ....................................................................... 42 La elección del lenguaje de programación y del sistema operativo ................................... 42 Propuesta de solución ............................................................................................................. 443 Características de la solución ................................................................................................... 43 CAPITULO 6 DESCRIPCION DE LA SOLUCION .................................................................. 44 Modelo propuesto. ..................................................................................................................... 45 Componentes .............................................................................................................................. 46 Requerimientos funcionales y no funcionales ....................................................................... 49 Casos de Uso............................................................................................................................... 51 Análisis y Diseño (UML)......................................................................................................... 577

6

Contenido CAPITULO

CAPITULO 7 CONCLUSIONES Y TRABAJO FUTURO ...................................................... 678 Conclusiones ............................................................................................................................. 688 Trabajo futuro ............................................................................................................................. 69 APÉNDICE 1 IMPLEMENTACIÓN EN LA PLATAFORMA WINDOWS PHONE 7......... 71 APÉNDICE 2 CODIGO FUENTE ................................................................................................ 83 REFERENCIAS BIBLIOGRÁFICAS............................................................................................ 96

7

CAPITULO

Lista de Figuras Figura 3.1. Estructura de un sistema operativo ........................................................................ 18 Figura 3.2 Logotipo comercial de Andrid© ................................................................................ 19 Figura 3.3 Logotipo comercial de Symbian© ............................................................................. 20 Figura 3.4 Logotipo comercial de Maemo© ............................................................................... 21 Figura 3.5 Logotipo comercial de iOS© ...................................................................................... 22 Figura 3.6 Logotipo comercial de WP7© ................................................................................ 3822 Figura 4.1. Representación de una imagen original en escala de grises y su binarización. . 34 Figura 4.2. Erosión con un operador de un solo renglón y dos columnas ............................. 38 Figura 4.3. Imagen erosionada. .................................................................................................... 38 Figura 4.4. Dilatación con un operador de un solo renglón y dos columnas ........................ 38 Figura 4.5.. Dilatación con un operador en forma de L ............................................................ 38 Figura 4.6. Imagen con dilatación. ............................................................................................... 39 Figura 6.1 Arquitectura VMS ....................................................................................................... 45 Figura 6.2 Requerimientos funcionales del sistema ................................................................. 50 Figura 6.3 Requrimientos no funcionales del sistema .............................................................. 51 Figura 6.4. Casos de uso del sistema 1 ......................................................................................... 53 Figura 6.5. Casos de uso del sistema 1 ........................................................................................ 53 Figura 6.6. Casos de uso del sistema 2 ........................................................................................ 53 Figura 6.7 Diagrama de clases: Habilitar Servicios ................................................................... 58 Figura 6.8 Diagrama de actividades: Habilitar Servicios.......................................................... 59 Figura 6.9.. Diagrama de secuencia: Habilitar Servicios ......................................................... 538 Figura 6.10.. Diagrama de colaboración: Habilitar Servicios ................................................... 60 Figura 6.11 Diagrama de clases: Aplicar Algoritmos ................................................................ 60 Figura 6.12 Diagrama de actividades : Aplicar Algoritmos ................................................... 611 Figura 6.13 Diagrama de secuencia: Aplicar Algoritmos ......................................................... 61 Figura 6.14 Diagrama de colaboración: Aplicar Algoritmos.................................................... 62 Figura 6.15 Diagrama de clases: Validar Algoritmos .............................................................. 622 Figura 6.16 Diagrama de actividades : Validar Algoritmos ..................................................... 63 Figura 6.17 Diagrama de secuencia: Validar Algoritmos ......................................................... 63 Figura 6.18 Diagrama de colaboración: Validar Algoritmos.................................................... 64 Figura 6.19 Diagrama de clases: Enviar Datos ........................................................................... 64 Figura 6.20 Diagrama de actividades : Enviar Datos ................................................................ 65

8

Lista de figuras CAPITULO

Figura 6.21 Diagrama de secuencia: Enviar Datos .................................................................... 65 Figura 6.22 Diagrama de colaboración: Enviar Datos ............................................................... 66 Figura 8.1 – El propio instalador se descargará el software necesario. ................................. 73 Figura 8.2 – Inicio de Visual Studio 2010 para Windows Phone 7 .......................................... 74 Figura 8.3 – Seleccionar tipo de proyecto en Visual Studio ..................................................... 74 Figura 8.4 – Simulación de WP7 ................................................................................................... 77 Figura 8.5 – Selección de aplicación en Visual Studio 2010...................................................... 78 Figura 8.6 – Entorno Visual Studio 2010 ..................................................................................... 78 Figura 8.7 – Agregar botón en entorno Visual Studio 2010...................................................... 79 Figura 8.8 – Emulador de WP7 en Visual Studio 2010 .............................................................. 80 Figura 8.9 – Ejecución de emulador de WP7 en Visual Studio 2010 ....................................... 81 Figura 8.10 – Ejecución de emulador de WP7 en Visual Studio 2010 ..................................... 81 Figura 9.1 – Ejecución de emulador de WP7 con la aplicación propuesta en Visual Studio 2010 ................................................................................................................................................... 95

9

CAPITULO

Lista de Tablas Tabla 5.1 Comparativa de los sistemas operativos móviles ................................................... 42 Tabla 6.1. Casos de Uso: Habilitar servicios. .............................................................................. 55 Tabla 6.2. Casos de Uso: Aplicar algoritmos .............................................................................. 55 Tabla 6.3. Casos de Uso: Validar algoritmos .............................................................................. 39 Tabla 6.4. Casos de Uso: Enviar datos ......................................................................................... 81

10

CAPITULO

11

CAPITULO

Capítulo I. Introducción

En el mercado actual, existen diferentes plataformas de procesamiento móvil, denominadas en delante simplemente como plataformas móviles, en distintos niveles de desarrollo con referencia a su consolidación como entornos de desarrollo y distribución de aplicaciones. Cada plataforma provee sus propias prestaciones y sus propios lenguajes de programación. Este panorama es muy similar a la historia del computador de escritorio durante los años 80‟s, donde existían diversas plataformas aisladas y donde un programador de aplicaciones necesitaba cierto conocimiento experto sobre el conjunto de prestaciones específicas de cada entorno de desarrollo. En la actualidad, una tendencia de coordinación entre los fabricantes de dispositivos y los desarrolladores de aplicaciones comienza a tomar forma generando plataformas cada vez más uniformes, pero lejos aún de proveer entornos de programación mixta multiplataforma. Bajo este entorno, esta tesis pretende estudiar a profundidad las características de una de las plataformas móviles representativa que se disponen en el mercado con el objetivo de evaluar su disponibilidad y robustez frente al desarrollo de aplicaciones de control robótico basado en información visual, también conocido en su versión compacta como control visual. Este estudio pretende sentar los cimientos de trabajo en este tópico al interior del grupo de robótica, visión computacional y control automático del Centro Universitario de Ciencias Exactas e Ingenierías.

Planteamiento del Problema En la actualidad las tecnologías relacionadas al desarrollo de aplicaciones para plataformas móviles se encuentran en un periodo de consolidación, dando lugar a casi una decena de entornos para sistemas móviles que se han presentado en el mercado, entre las cuales podemos mencionar: Android, BREW Symbian©, BlackBerry©, Palm© y iPhone OS© entre otros. Otro competidor, actualmente es Windows Phone 7 por lo que la plataforma que se abordará en el estudio es esta última, se eligió en base a su hardware y las prestaciones de software que ofrece a partir de la WP7. La importancia de implementar procesamiento de imágenes en la plataforma elegida radica principalmente en la precedencia que implica en áreas como la robótica y en aplicaciones comerciales que ayuden al usuario en la toma correcta de decisiones en los diferentes servicios que ofrecen estos teléfonos inteligentes. Esto se realizará mediante algoritmos de control visual.

12

Introducción CAPITULO

Pregunta de Investigación ¿Cómo hacer una aplicación con control visual para una plataforma móvil aprovechando la concurrencia de hardware con múltiples prestaciones y entorno operativo de alto nivel?

Justificación En las plataformas para móviles se incluyen librerías de desarrollo y entornos de programación propietarios de cada sistema. El desarrollo e instalación de aplicaciones orientadas a la solución del problema de control visual basado en plataformas móviles puede realizarse gracias a la vasta disposición de recursos de proceso en hardware y software que se proveen en las distintas plataformas. Su exploración y posterior implementación permitirá el desarrollo del conocimiento alrededor de estas plataformas, así como el desarrollo de conceptos nuevos para implementar el control y regulación basada en retroalimentación visual en plataformas móviles.

Hipótesis Las prestaciones que una plataforma móvil ofrece son comunes a la mayoría de entornos de programación. Se dan las condiciones necesarias para establecer una aplicación que se desarrolle en la plataforma previamente seleccionada, de forma tal que se desarrolle una aplicación simple de control visual utilizando las prestaciones del entorno de programación y prueba.

Objetivos 

Objetivo general Estudiar una plataforma seleccionada de sistemas móviles con aplicaciones simples y concisas basados en algoritmos de control visual.



Objetivo particular -

Analizar las capacidades de las distintas plataformas de procesamiento móvil disponibles en el mercado.

-

Desarrollar aplicaciones prototipo de visión por computadora sobre una plataforma móvil seleccionada.

-

Implementar y efectuar pruebas de operación sobre los prototipos robóticos con control visual.

13


Metas del trabajo - Estudio de una plataforma que ofrecen un rendimiento mayor en proceso de imágenes en tiempo real. - Desarrollo de cuando menos una aplicación para el proceso de imágenes en una plataforma móvil. - Planteamiento de los procesos a seguir para obtener el aprendizaje del modelo de programación de la plataforma seleccionada

Contribuciones El sentido y valor de este trabajo fuera de los retos de desarrollar aplicaciones en una plataforma para el WP7 desconocida para mi hasta antes de iniciar esta tesis y el aprendizaje que conllevo trabajar con un lenguaje de programación específico para esta plataforma, así como los retos tecnológicos tales como obtener el software necesario así como las herramientas de trabajo, modelar los programas en un simulador y el mismo dispositivo para hacer las pruebas de instalación, entre otros que tuve que afrentar al explorar en una plataforma cerrada; es el enfoque didáctico que se ha logrado obtener de todos estos conocimientos. El resultado de esta tesis es poder contribuir al aprendizaje de conceptos y procesos que no se obtienen fácilmente en los libros de texto y que lleva una fuerte dedicación de tiempo cubrirlos en los foros de discusión en Internet. Para quién lea esta tesis el beneficio será que pueda descubrir resultados en menos tiempo en el proceso base para desarrollar aplicaciones en el sistema operativo WP7 así como desarrollar aplicaciones en este sistema operativo con algoritmos de control visual.

Estructura del trabajo En el capítulo 2 una breve reseña de la evolución que las computadoras y dispositivos móviles, que han dado pie a los dispositivos móviles que existen en la actualidad. En el capítulo 3 se presentan las plataformas existentes en el mercado así como la plataforma seleccionada con la cual se trabajará para la programación con algoritmos de control visual. También se presenta una breve descripción de los lenguajes de programación que se usan para la programación de móviles.

En el capítulo 4 se esbozarán los métodos de visión artificial que se usarán en el capítulo 6 tales como dilatación, erosión, flujo óptico, operador sobel.

14


En el capítulo 5 se plante la problemática a resolver mediante la selección de dispositivos móviles. En el capítulo 6 la solución al problema planteado en el capítulo 5, proponiendo un una arquitectura para los requerimientos del sistema al utilizar los algoritmos de visión artificial. En el capítulo 7 se presentarán las conclusiones de la tesis en base a los resultados obtenidos a lo largo del desarrollo de la misma. Y el trabajo futuro a realizar en base a las conclusiones ya analizadas bajo la arquitectura ya seleccionada. Finalmente se anexan dos apéndices, en el primero el desarrollo de una aplicación de video en la plataforma WP7 y en el segundo apéndice el código fuente generado para la aplicación basada en la arquitectura propuesta en esta tesis.

15

CAPITULO

16

CAPITULO

CAPITULO 2 ANTECEDENTES A través del tiempo las computadoras, han cambiado de forma, tamaño, capacidad, composición y han adquirido nuevas funciones para resolver diferentes tipos de problemas o facilitar tareas específicas. Desde el principio del mundo el hombre tuvo la necesidad de contar sus pertenencias. Los primeros métodos que utilizó el hombre para contar fueron los dedos de la mano y los pies, marcas en la tierra, semillas y piedras. A medida que su vida se fue complicando, fue necesaria la creación de artefactos para realizar operaciones de una forma más simple y rápida. El ábaco es el artefacto más antiguo del que se tiene conocimiento para realizar cómputos matemáticos. Esto abrió las puertas a nuevos inventos, la Calculadora de Pascal (Pascalina). Posteriormente basada en el modelo de Pascal surge una serie de mejoras creando otras calculadoras por ejemplo la Máquina de multiplicar de Leibniz, años después Charles Xavier Thomas inventó una calculadora [1]. que podía llevar a cabo las cuatro operaciones matemáticas básicas (sumar, restar, dividir y multiplicar) por mencionar algunas. La evolución de estas máquinas para resolver operaciones cada vez más complicadas se vio reflejada por el año 1822 cuando se invento la máquina diferencial de Babbage la cual fue diseñada para trabajar con vapor, tenía como función resolver ecuaciones diferenciales. Durante el transcurso del tiempo Babbage comenzó a trabajar en la primera computadora de uso general o máquina analítica.

Evolución de las Computadoras En los primeros años de los computadores usaban tubos al vacío para procesar información, tarjetas perforadas para entrar los datos y cilindros magnéticos para almacenar información e instrucciones internas. Eran sumamente grandes, utilizaban gran cantidad de electricidad, generaban gran cantidad de calor y eran sumamente lentas. En una segunda etapa el desarrollo de los computadores tenía una mejora que provenía tanto de los avances tecnológicos como de innovaciones en el diseño y se debió principalmente al progreso en la tecnología de semiconductores, que obtuvo mejoras impresionantes en densidad, velocidad y disipación de potencia.

17

Antecedentes CAPITULO

Antes de los circuitos integrados, las computadoras estaban diseñadas para aplicaciones científicas o de negocios, pero no para las dos cosas. Los circuitos integrados permitieron a los fabricantes de computadoras incrementar la flexibilidad de los programas, y estandarizar sus modelos. Con el surgimiento de las computadoras personales, el software y los sistemas que con ellas de manejan han tenido un considerable avance, porque han hecho más interactiva la comunicación con el usuario. Finalmente aparecen los microprocesadores que son circuitos integrados de alta densidad y con una velocidad impresionante. A raíz de estos nacen las computadoras personales, el software y los sistemas que con ellas se manejan han tenido un considerable avance, porque han hecho más interactiva la comunicación con el usuario. Con la utilización de computadoras portátiles (en las cuales se pueden realizar las mismas tareas que en una computadora de escritorio), nacen nuevos retos para sacar provecho a esta portabilidad. Uno de esos retos se ha visto reflejado en los dispositivos móviles los cuales actualmente tienen un sinfín de aplicaciones simulando la utilización de una computadora. Es aquí donde queremos probar que tan eficiente puede ser una aplicación de visión artificial para control visual.

Evolución de los dispositivos móviles Un dispositivo móvil se puede definir como aquel micro-ordenador que es lo suficientemente ligero como para ser transportado por una persona, y que disponen de la capacidad de batería suficiente como para poder funcionar de forma autónoma [2]. El primer dispositivo móvil, para muchos, es la Newton[2]., era un dispositivo revolucionario para su tiempo, que implementaba un sistema de reconocimiento de escritura y que podía sincronizarse con un ordenador de sobremesa. El teléfono móvil se remonta a los inicios de la Segunda Guerra Mundial, donde ya se veía que era necesaria la comunicación a distancia. Esta tecnología fue aprovechada a partir de los años 50 y 60 para crear una gran variedad de aparatos de radio y de comunicación a distancia, utilizados sobre todo por servicios públicos tales como taxis, ambulancias o bomberos. La primera generación o 0G eran celulares que estaban integrados a algunos automóviles, teniendo un transmisor en la parte trasera de éste. Después de estos los 1G utilizaron tecnología analógica y solamente se podía transmitir voz. La evolución a estos primeros celulares fue para 2G que se convirtió en un sistema digital, en estos celulares el tamaño cambió drásticamente al igual que su peso y ya se

18

Antecedentes CAPITULO

podía transferir datos además de voz. Para la generación 3G se crearon 3 tipos de tecnologías la UMTS (Universal Mobile Telecommunication System) usando CDMA (Acceso Multiple por División de Código) de banda ancha, este sistema proporciona la transmisión de datos en paquetes y por circuitos de conmutación de alta velocidad que es la tecnología utilizada actualmente. Estos celulares han evolucionado hasta llegar a los SMARTPHONE el cual es un teléfono móvil que incorpora características de una computadora personal. El primer Smartphone fue lanzado por IBM y Bellsouth en 1993, este teléfono disponía de 1 megabyte de memoria y una pantalla táctil blanco y negro con una resolución de 160 x 293 pixeles, entre sus funciones que manejaba eran el de teléfono, localizador de personas, calculadora, libreta de direcciones y un dispositivo de correo electrónico. Estos dispositivos cuentan actualmente con muchas ventajas sobre los primeros celulares, desde el almacenamiento de datos hasta las cámaras que utilizan. Estos dispositivos al igual que la computadora cuentan con un sistema operativo el cual es llamado SO móvil, en el siguiente capítulo hablaremos un poco de las diferentes plataformas que tenemos disponibles actualmente. Las ventajas que traen consigo estos dispositivos móviles en la actualidad al tener mayor espacio de almacenamiento, contar con cámaras de alta definición y un mayor tiempo de duración en la batería es que nos da la oportunidad de probar aplicaciones con algoritmos de visión artificial y medir las capacidades logradas en una computadora portátil o de escritorio contra los resultados que se están obteniendo en los Smartphone.

19

CAPITULO

20

CAPITULO

CAPITULO 3 SISTEMAS OPERATIVOS Un sistema operativo es un programa que controla la ejecución de los programas de aplicación y que actúa como interfaz entre el usuario de un computador y el hardware de la misma. [3] Un sistema operativo puede ser contemplado como una colección de software del hardware, que consiste en rutinas de control que hacen funcionar al computador y proporcionan un entorno para la ejecución de programas.

Figura 3.1. Estructura de un sistema operativo

Al igual que las computadoras los dispositivos móviles cuentan con un sistema operativo el cual permite que las acciones que puedan hacerse se asemejen cada vez más a las actividades que se pueden realizar en una laptop.

Sistemas operativos para dispositivos móviles Los dispositivos móviles se conforman de una gran variedad de circuitos electrónicos que permiten implementar distintas funcionalidades que se integran en un solo dispositivo. Se incluyen distintos componentes como procesadores de audio, codificadores de vídeo, cámaras digitales, memoria de servicio, etc. De ahí que un número importante de aplicaciones se han desarrollado en proporciones exponenciales, desde aquellas aplicaciones que aprovechan funcionalidades de software hasta sistemas de almacenamiento y clasificación de datos.

21

Sistemas Operativos CAPITULO

Por lo que la programación para móviles cada vez más se va enfocando a la interconectividad entre los dispositivos porque el contenido creado para un teléfono inteligente permite acceder a datos de los usuarios en la Web para enviar y recibir correo electrónico y en la actualidad está iniciando el poder realizar transacciones de comercio electrónico y otras aplicaciones sofisticadas que necesitan de la autentificación esencial e información de identidad del usuario, sin embargo, la Internet móvil está en su infancia, y los dispositivos móviles están rápidamente convirtiéndose en algo más que simples dispositivos. Igual que las computadoras, los dispositivos móviles cuentan con un sistema operativo. Un SO móvil es el software de la plataforma sobre la cual otros programas, se pueden ejecutar[4]. Las plataformas para móviles existen dependiendo de los diferentes dispositivos que oferta el mercado y las prestaciones son comunes a la mayoría de entornos de programación. Las plataformas más exitosas y conocidas dentro del mercado móvil, destacan las siguientes 5:

Figura 3.2. Logotipo comercial de Android© 1. Android La plataforma de Google para móviles tiene como nombre Android. El sistema operativo está basado en Linux, así como una interfaz gráfica y una serie de aplicaciones que se puede adaptar a diversos teléfonos celulares, esta plataforma usa el lenguaje Java para crear aplicaciones a través de la biblioteca de Java SE utilizando Apache Harmony, también optimiza una máquina virtual llamada “Dalvik”. Su base radica en lo siguiente: sistema de aislamiento de procesos, MNG memoria y trabajo mediante hilos totalmente independiente de Sun y JCP. Una de sus características es que utiliza la API de Java para comunicaciones básicas, ubicación, SQLite, OpenGL y SuncML. Incluye un kit del lenguaje C/C++ para utilizarlo en diversos componentes de su sistema, las bibliotecas de este kit están disponibles para los desarrolladores de esta plataforma a través del Framework APIs.

22

CAPITULO Sistemas Operativos

Figura 3.3 Logotipo comercial de Symbian© 2. Symbian Esta plataforma es propiedad de Ericsson, Panasonic, Siemens AG, Nokia y Sony-Ericsson y se basa en EPOC que fue empleado en las antiguas computadoras de bolsillo Psion. La plataforma Symbian, es utilizada en el sistema operativo para dispositivos móviles con recursos limitados, ya que ahorra siempre que puede espacio en memoria y apaga el procesador cuando no se utiliza aumentando así la vida de la batería. Las principales características de esta plataforma son que tiene una interfaz de usuario a través del Framework, utiliza la API de C++ y trabaja con multitarea, multihilo, y protección de memoria. Esta plataforma está basada en eventos y objetos activos, conservación de la memoria, fiabilidad y optimización del CPU. Los componentes de Symbian son el kernel, aplicación, servidor, un motor. El kernel administra y controla el acceso del hardware así como los privilegios del hardware compatible. Las aplicaciones son programadas en una interfaz de usuario y se ejecutan en modo usuario. Su servidor es un programa sin una interfaz de usuario, administra los recursos y proporciona una interfaz para los clientes, también cuenta con un servidor de archivos, un servidor de ventanas, comunicaciones, etc. Y por último el motor que es una pieza de la aplicación que manipula los datos por lo general separada del DLL. El sistema modelo de Symbian contiene las siguientes capas: capa de interfaz de usuario Framework, capa servicio de aplicaciones, Java ME, capa OS (utilizada para servicios genéricos del sistema operativo y comunicaciones), capa servicio de base, capa servicio del kernel e interfaz del hardware. Recientemente, en la versión 9.x de Symbian, la mayoría de las aplicaciones deben ser certificadas a través de una firma mediante un proceso centralizado que ofrece Symbian Ltd. con la finalidad de poder instalarse y ejecutarse en el dispositivo móvil. Una aplicación sin certificado tiene características muy limitada, una motivación para realizar este proceso llamado Symbian Signed es mejorar la seguridad previniendo

23


la instalación y la ejecución de posibles programas desconocidos y peligrosos o dañinos, ya que varios virus y troyanos se han desarrollado para esta plataforma, por ejemplo, Cabir, y han causado una serie de productos anti-virus para dispositivos móviles.

Figura 3.4 Logotipo comercial de Maemo©

3. MAEMO MAEMO, es una plataforma para desarrollo de código abierto en aplicaciones para Nokia Internet Tablets y otros dispositivos basados en Linux, se fundamenta a través de Maemo SDK. La plataforma Maemo de Nokia incluye el Internet Tablet OS, que se basa en Debían GNU / Linux y se apoya para su interfaz gráfica de usuario, en gran parte en frameworks y bibliotecas de proyecto en GNOME. Maemo está cimentado en el kernel del sistema operativo de Linux, el cual es un kernel monolítico que soporta múltiples plataformas de hardware. Utiliza el gestor de ventanas Matchbox y al igual que Ubuntu Mobile utiliza el Hildon, el cual se fundamenta en GTK como GUI y Framework para el desarrollo de sus aplicaciones. Esta plataforma es utilizada principalmente para Internet Tablet, que son más pequeñas que las que traen las computadoras portátiles, pero más grandes y más versátiles que las del PDA. Un Tablet puede tener un pequeño teclado y las características centrales incluyen un lápiz óptico y una pantalla sensible al tacto. Las interfaces gráficas se deben diseñar pensando en la pantalla táctil.

24


Figura 3.5 Logotipo comercial de iOS© 4. iPhone OS El sistema operativo iPhone OS (plataforma iOS) fue creado por Apple Inc. para los dispositivos móviles del iPhone y los productos del iPod touch y iPad. Esta plataforma se deriva del sistema operativo Mac OS X. Su arquitectura está basada en cuatro capas de abstracción llamadas Core OS layer, Core Services layer, Media layer y Cocoa Touch layer. El sistema operativo de Mac OS X tiene un API llamada Cocoa la cual trabaja con la metodología orientada a objetos, la ventaja es que se reduce el tiempo de desarrollo, la desventaja es que demanda a los programadores un alto nivel de formación. En estas plataformas (iOS y Mac OS X) es posible programar con varios lenguajes de programación pero los más usados son Java y Objective-C.

Figura 3.6 Logotipo comercial de WP7© 5. Windows Phone7 Series Por su parte Microsoft está desarrollando la plataforma que incluye herramientas gratuitas para Windows Phone7 Series y mejoras con Silverlight que permiten nuevas experiencias en el desarrollo de aplicaciones y juegos para móviles. Es así como la programación para Windows© ha dado en gran medida la base para el desarrollo de aplicaciones para móviles. Una de las plataformas que ofrece trabajar con el desarrollo de estas aplicaciones móviles es la ya mencionada Windows Phone7 series (entre otras versiones de Windows©). Esta versión en particular ofrece unos requisitos de

25


hardware muy elevados así como un ambiente de trabajo más homogéneo ofreciendo soporte multitarea y la programación es a través de herramientas de desarrollo que incluyen MS Visual Studio© y Express Blend©, apoyadas en un emulador que permite comprobar el correcto o incorrecto funcionamiento de las aplicaciones diseñadas [5] [6].

Lenguajes de programación para dispositivos móviles Los lenguajes de programación para los dispositivos móviles dependen en gran parte del dispositivo en el que se quiera trabajar, sin embargo tienen en común que se puede crear sistemas visuales robustos con mayor facilidad independientemente del lenguaje de programación que se esté aplicando, por supuesto dicho lenguaje debe soportar la metodología de programación con la que trabaja el dispositivo en particular. Otra ventaja importante es la reutilización de código; para poder reutilizar código existente que nos simplifique el desarrollo de una interfaz de usuario gráfica es necesario conocer y adentrarse en las librerías existentes en los diversos lenguajes de programación para dispositivos móviles. Ahora una vez que se conocen y se pueden aplicar en una interfaz de consola para el usuario será mucho más sencillo ubicarlos dentro de las clases existentes y aplicar el tema adecuado dependiendo de lo que se necesite personalizar de acuerdo a la naturaleza de cada sistema. Los lenguajes de programación se pueden clasificar de diferentes formas, ya sea por su nivel o por sus aplicaciones, este último generalmente es utilizado para clasificar a los lenguajes de programación para dispositivos móviles. Las aplicaciones pueden ser con un solo hilo de control dirigidas a eventos, esto quiere decir que sólo tendrá una aplicación en ejecución en un tiempo determinado, o bien desarrolladas para multi-tarea. A continuación se describen algunos de los lenguajes de programación que pueden ser usados en el desarrollo de aplicaciones para dispositivos móviles.

Java Para dispositivos móviles la versión de Java en la que se programa es J2ME (Java Micro Edition), esta versión contiene una colección de tecnologías y de especificaciones para el desarrollo de aplicaciones con capacidades restringidas tanto en pantalla gráfica como de procesamiento y memoria. Contiene un perfil para dispositivos de información móvil conocido como MIDP (Mobile Information Device Profile), este perfil se apoya en CLDC (Connected Limited Device Configuration) y proporciona los paquetes y clases

26

CAPITULO Sistemas Operativos necesarios. Una aplicación MIDP o MIDlet es aquella que sólo utiliza las APIs definidas por la arquitectura MIDP o CLDC [7]. En el caso del lenguaje de java que es nuestra herramienta de trabajo para la aplicación de la metodología orientada a objetos, existe un paquete que reúne a las clases que nos permiten implementar lo que se conoce como GUI (Graphic User Interface). Las iniciales AWT significan en inglés Abstract Windows Toolkit; la principal característica de utilizar las clases que se encuentran en este paquete es que el ambiente visual programado tendrá el diseño dependiendo de la plataforma en donde nos encontremos, es decir si estamos programando en el sistema operativo Windows se adoptará éste ambiente visual para la interfaz del usuario, de la misma forma si estamos en el sistema operativo de Macintosh o cualquier otro sistema operativo, adoptará el diseño de los componentes de dicho sistema. Existe otro paquete que se desarrollo a partir de la segunda versión del lenguaje de java el cual se llama Swing implementa varias partes de AWT, su ventaja es que provee mayor afinidad y se comporta de la misma manera en las diferentes plataformas, otra ventaja sobre AWT es que Swing contiene abundantes funcionalidades nuevas. Por lo que los desarrolladores prefieren utilizar Swing a pesar de que en todas las versiones existentes de java sigue estando disponible AWT.

Lenguaje de C++ Una de las herramientas que se utilizan para la programación de móviles basadas en el lenguaje de C++ es Carbide.c++ la cual trabaja en la plataforma de Symbian, esta herramienta es desarrollada por Nokia. Las aplicaciones son construidas en el marco de eclipse. Existen varias versiones que se enlistan a continuación: -

Caribe.c++ OEM Edition. Esta versión está enfocada a los usuarios creadores del dispositivo.

-

Carbide.c++ Profesional. Es una versión para los desarrolladores que trabajan con los dispositivos de pre-producción. Carbide.c++ Developer Edition. Esta diseñada para el desarrollo de aplicaciones en los teléfonos. Carbide.c++ Express, es una versión sin costo para dar una experiencia en programar aplicaciones para móviles.

-

27


Cuenta con paneles que son vistas donde se organiza el desarrollo de la aplicación, así como el poder generar makefiles que traen como ventaja la reconstrucción rápida basada en los archivos [7]. Otra herramienta es Visual C++, en la que se programa directamente en el lenguaje C++ el cual se conoce como un lenguaje “nativo” de desarrollo ya que trabaja directamente con el hardware del dispositivo Windows Mobile, sin capas intermedias por lo que no es un lenguaje trivial para aprender. Este lenguaje corre muy rápido y consume muy pocos recursos, utiliza la API de Win32 (Application Program Interface functions) para interactuar con el dispositivo.

Lenguaje de C# Para desarrollar aplicaciones en dispositivos móviles a través de este lenguaje de programación se puede utilizar la herramienta de Visual C# que trabaja con un IDE para diseñar las ventanas de la aplicación. La sintaxis de C# es muy expresiva y está basada en signos de llave, las personas que ya han trabajado con los lenguajes de C, C++ y Java podrán introducirse en este lenguaje sin mayor problema, por lo que los desarrolladores que conocen cualquiera de estos lenguajes pueden empezar a trabajar de forma productiva en C# en un corto lapso de tiempo. El lenguaje de C# facilita en su mayoría la complejidad del lenguaje de C++ y al mismo tiempo, ofrece funciones eficientes para los tipos de valores que aceptan valores NULL, enumeraciones, delegados, métodos anónimos y acceso directo a memoria, que no se encuentran en Java. C# también acepta métodos y tipos genéricos, que proporcionan mayor rendimiento y seguridad de tipos, que permiten a la implementación de las clases de colección definir comportamientos de iteración personalizados que se pueden utilizar fácilmente. Este lenguaje usa la metodología orientado a objetos, por lo que acepta los conceptos de encapsulación, herencia y polimorfismo, el encapsulamiento se puede apreciar a simple vista ya que todas las variables y métodos, incluido el método principal que es el punto de entrada a la aplicación en ejecución, se encapsulan dentro de definiciones de clase. Una clase puede heredar directamente de una clase primaria, pero puede implementar cualquier número de interfaces. Los métodos que reemplazan a los métodos virtuales en una clase primaria requieren la palabra clave override como medio para evitar redefiniciones accidentales. En C#, una estructura es como una clase sencilla; es un tipo asignado en la pila que puede implementar interfaces pero que no admite la herencia. El proceso de generación de C# es simple en comparación con el de C y C++, y es más flexible que en Java. No hay archivos de encabezado independientes, ni se requiere

28


que los métodos y los tipos se declaren en un orden determinado. Un archivo de código fuente de C# puede definir cualquier número de clases, estructuras, interfaces y eventos.

Objective - C Este lenguaje de programación está basado en C y a diferencia de C++ es un supe conjunto del lenguaje C, ya que agrega a la sintaxis de C la manera de enviar mensajes en Small-Talk y de definir e implementar objetos. Contiene un Run Time System que es un sistema auxiliar que permite hacer la tipificación dinámica y el ligado dinámico. Su principal característica es que ejecuta de forma rápida el llamado de funciones y permite tener una tipificación estática de ser requerido, por otra parte maneja la persistencia de objetos por número de referencias [8]. El lenguaje utiliza la programación orientada a objetos y se trabaja con dos archivos para poder crear aplicaciones, un archivo .h en la cual se define la clase y un archivo .m para implementar dicha clase. Objective C a diferencia de otros lenguajes orientados a objetos, siempre que sea posible aplaza las decisiones que otros lenguajes toman en tiempo de compilación para el tiempo de ejecución. Esto implica que necesite de un compilador así como de un runtime que proporcione servicios al lenguaje en tiempo de ejecución haciendo que las aplicaciones actúen con el runtime por lo menos en tres niveles los cuales se explican a continuación: - Mediante el código fuente: aquí el runtime suministra servicios al programa de forma transparente, es decir, el compilador traduce instrucciones del lenguaje en llamadas al runtime, también el compilador crea estructuras de datos a partir de la información encontrada en el código fuente, como objetos clase u objetos protocolo. - Mediante los métodos de la clase principal: se refiere a que los objetos heredan métodos de la clase padre que sirve para acceder al runtime. - Mediante llamadas a las funciones de runtime: es posible encontrar un conjunto de funciones C que permiten a la aplicación interactuar directamente con el runtime a través de los archivos de cabecera del directorio [9].

.NET Es un Framework (estructura de soporte para organizar y desarrollar software) de Microsoft que permite un rápido desarrollo de aplicaciones. Microsoft .NET Framework 3.5.1 combina la eficacia de las API de .NET Framework 2.0 y 3.0 con nuevas tecnologías

29


para crear aplicaciones que ofrecen interfaces de usuario atractivas, protegen la información de identidad personal de los clientes, permiten una comunicación segura y sin problemas, y proporcionan la capacidad de modelar diversos procesos de negocio. .NET Framework proporciona algunas características básicas que facilitan la implementación de una amplia gama de aplicaciones. Entre estas características se incluyen: - Aplicaciones carentes de impacto: esta característica permite aislar la aplicación y eliminar conflictos de archivos DLL. De forma predeterminada, los componentes no afectan a otras aplicaciones. - Componentes privados predeterminados: de forma predeterminada, los componentes se implementan en el directorio de la aplicación y sólo son visibles para la aplicación en la que están incluidos. - Uso compartido de código controlado: para compartir código es necesario hacer que éste quede disponible para compartir explícitamente, mediante la modificación del comportamiento predeterminado. - Control de versiones simultáneas: es posible que coexistan varias versiones de un componente o de una aplicación; el usuario puede elegir las versiones que desea utilizar, y Common Language Runtime impone la directiva de control de versiones. - Implementación y duplicación mediante XCOPY: los componentes y aplicaciones autodescriptivos e independientes pueden implementarse sin entradas del Registro o dependencias. - Actualizaciones inmediatas: los administradores pueden utilizar servidores host, como ASP.NET, para actualizar programas de archivos DLL, incluso en equipos remotos. - Integración con Microsoft Windows Installer: a la hora de implementar la aplicación, estarán disponibles las características de anuncio, edición, reparación e instalación a petición. - Implementación de empresa: esta característica proporciona una distribución de software sencilla, que incluye el uso de Active Directory. - Descarga y almacenamiento en caché: el incremento de descargas reduce el tamaño de las mismas, y los componentes pueden aislarse a fin de que sólo los utilice la aplicación para una implementación de impacto cero. - Código que no es de plena confianza: la identidad se basa en el código en lugar de basarse en el usuario, el administrador establece la directiva y no aparecen cuadros de dialogo de certificado.

30


Python Este lenguaje de programación orientado a objetos es utilizado para dispositivos móviles tales como Symbian, Palm, teléfonos inteligentes de Nokia, etc., también se puede emplear en otras plataformas tales como Windows, Linux/Unix, Mac OS X, OS/2 y también ha sido portado para maquinas virtuales de Java y .Net, distribuido bajo la licencia de código abierto OSI lo hace libre en su uso. Algunas de las características de Python son: portabilidad, versatilidad, simplicidad, interactividad, su sintaxis es clara y legible, productividad, código abierto, entre otras.

31

CAPITULO

32

CAPITULO

CAPITULO 4 VISION POR COMPUTADORA En esta tesis utilizaremos algunas técnicas de visión por computadora aprovechando la potencia que puede tener un dispositivo móvil. Desde una perspectiva general, la visión por computadora es la capacidad de la máquina para ver el mundo que lo rodea, esta intenta recrear un mundo tridimensional basándose en la adquisición de imágenes bidimensionales. El campo de la visión por computadora surgió en la década de los 50‟s junto con las primeras computadoras, en un comienzo se pusieron grandes expectativas en esta área pero debido a las limitaciones presentadas por los sistemas de computo su estudio fue prácticamente abandonado. Fue hasta que el amplio desarrollo que tuvieron las computadoras durante la década de los 80‟s, permitió realizar tareas mucho más complejas. Actualmente el área de visión por computadora no puede considerarse totalmente madura, pero se encuentra en constante desarrollo y su aplicación práctica es una realidad incluso en aparatos de uso cotidiano como las cámaras fotográficas. Los procesadores de hoy en día y en general los equipos de computo cuentan con características suficientes para ejecutar tareas mucho más complejas que aquellas a las que difícilmente podíamos aspirar hace unos pocos años, sin embargo el sistema diseñado para este trabajo buscara consumir la menor cantidad de recursos posibles haciendo uso de los algoritmos más eficientes, esto con el fin de poder ejecutar el procedimiento visual en el dispositivo móvil siendo capaz éste de aprovechar las ventajas de disponibilidad de memoria, un mejor procesador y alto rango de duración de batería con respecto de otros dispositivos móviles. En la actualidad estos procesamientos visuales empiezan a emigrar a los diferentes dispositivos móviles descritos en el capítulo 3, dando un paso muy importante en la aplicación del software para este tipo de plataformas.

Imagen El proceso de visión por computadora, se puede dividir en 3 grandes secciones explicadas a continuación: 1)

Procesamiento de la imagen: donde tenemos como entrada una imagen y como salida otra imagen procesada con técnicas de filtrado, eliminación de ruido u otro proceso para mejorar la imagen.

33

Visión por CAPITULO computadora

2)

Análisis de imagen: Se tiene una imagen como entrada y obtenemos mediciones en la salida, como son el flujo óptico, que nos permite extraer los centroides (centro de una mancha de píxeles) en vectores para diferentes usos en áreas como robótica, seguridad, industria, etcétera.

3)

Entendimiento de la imagen: Es un proceso de descubrimiento, identificación y entendimiento de patrones relacionados con la imagen, con la meta de emular la capacidad de análisis de visión de los seres humanos aplicando métodos y técnicas de programación.

Técnicas de procesamiento Binarización mediante detección de umbral El uso de umbrales en el tratamiento de imágenes es una de las prácticas más comunes para la detección de objetos ya que se eliminan muchos datos no necesarios para el proceso, la imagen obtenida esta formada únicamente por pixeles en blanco y negro, esto se refleja en una disminución importante en el tamaño del archivo que contiene a la imagen [10]. El caso más común se da en el campo de la visión industrial, donde los objetos suelen ser discriminados en base al brillo que presentan, de la misma manera, para facilitar el reconocimiento de los objetos, estos son colocados sobre fondos con intensidad de brillo muy diferente para evitar confusiones (por ejemplo, objetos claros sobre fondos obscuros y viceversa), para estos casos basta con obtener el histograma de intensidad de la imagen y discriminar en base a la formula, de esta manera, todos los pixeles con una intensidad de brillo por debajo del establecido cambiaran a un valor lógico de 0, lo que equivaldría al negro en la escala de colores, por otra parte aquellos pixeles con intensidad de brillo por arriba del umbral especificados serán desechados y su nuevo valor será de 1, equivalente a blanco, el resultado se puede observar en la figura A.

Figura 4.1. Representación de una imagen original en escala de grises y su binarización.

34


Flujo Óptico Casi todo trabajo relacionado con procesamiento de secuencia de imágenes comienza con la extracción del campo de vectores, el cual, describe como la imagen va cambiando conforme avanza el tiempo. Existen tres grandes grupos de problemas desde el punto de vista práctico que se presentan al examinar una secuencia de imágenes que muestra objetos en movimiento: 1) Detección del movimiento, siendo este el problema más sencillo de resolver se suele utilizar una simple cámara estática. 2) Detección y localización de los objetos en movimiento. Para la resolución de este caso una cámara se sitúa en una posición estática y los objetos se desplazan en la escena, o la cámara se mueve y los objetos permanecen estáticos o ambas cosas a la vez. Comúnmente el problema consiste en la detección del objeto, la detección de la trayectoria de su movimiento y la predicción de su futura trayectoria. 3) El último grupo trata de la obtención de propiedades 3D en base a diferentes a un conjunto de proyecciones 2D adquiridas en distintos instantes de tiempo. El análisis de movimiento se basa generalmente en un cierto número de imágenes consecutivas en una secuencia. El proceso es similar al de análisis de imágenes estáticas y consiste en buscar correspondencias entre las imágenes. Una representación bidimensional de un movimiento tridimensional se denomina campo de movimiento, en el cual cada punto (píxel) tiene asignado un vector de velocidad. Un enfoque diferente plantea la obtención del flujo óptico, que requiere un pequeño intervalo de tiempo entre imágenes consecutivas. La obtención del flujo óptico da como resultado la determinación de la velocidad y dirección del movimiento en todos los puntos de la imagen. A pesar de que el objetivo primario del flujo óptico es obtener el campo de movimiento estos no siempre se corresponden debido a los cambios de iluminación. Obtener el flujo óptico de una imagen es el método más simple computacionalmente hablando para calcular un área densa de movimiento que representa el movimiento aparente de todos los píxeles en una escena. Las áreas en movimiento se caracterizan por un campo vectorial, en el cual cada vector describe el desplazamiento de un píxel en la imagen. Los valores de los vectores se obtienen por medio de la comparación de imágenes secuenciales [10]. Desde sus inicios a finales de los 70, se han propuestos muchos métodos para la extracción del flujo óptico, los cuales pueden resumirse a tres tipos distintos en base a las

35


operaciones que se utilizan para el cálculo del campo vectorial, estas pueden ser de gradiente, de la frecuencia o de correlación; en general, todos ellos incorporan las siguientes etapas: 

Filtro pasa bajas o de alisamiento aplicado a las imágenes para remover el ruido generado por la degradación de la señal en el proceso de muestreo de las imágenes originales.



Extracción de datos para el cálculo del flujo óptico. Los datos extraídos en esta etapa dependen del tipo de método que se esté empleando.



Cálculo del flujo óptico en base a los datos que se extrajeron en el paso anterior.

Cuando el flujo óptico no es suficientemente bueno es resultado de alguna condición no favorable en la escena, las más comunes son:

Grandes desplazamientos de píxeles entre las imágenes: Algunas estrategias resuelven este problema aumentando la cantidad de imágenes procesadas por segundo pero el costo computacional se incrementa considerablemente. Un caso similar puede suceder si el desplazamiento es muy pequeño, este será muy difícil de detectar de un cuadro a otro.

Variaciones de iluminación en la escena: La variación en la iluminación de una escena causa cambios de intensidad (brillo) de píxeles.

Áreas de baja variación en intensidad o color (áreas con poca textura): Es posible que a pesar de que el flujo óptico sea correcto, este no corresponda al campo de movimiento. Un ejemplo que ilustra esto es una pelota con textura homogénea que gira sobre su propio eje. Debido a la superficie homogénea de la pelota el flujo óptico no indicaría desplazamiento de píxeles a través de la imagen.

Objetos ocluidos: Cuando un objeto ocluye otro (o a sí mismo) durante una secuencia de imagen, el flujo óptico es más difícil para calcular. El límite de esta oclusión también será un límite en el campo de movimiento, dos movimientos distintos

36


deberán ser percibidos en cualquier lado de este límite. Muchas técnicas de flujo ópticas tradicionales imponen ya sea una restricción global o local de suavidad en el flujo óptico, una restricción que es claramente violada por la discontinuidad evidente en este panorama. Algunas técnicas aplican métodos estadísticos robustos para el problema para solucionar este problema de movimientos múltiples. Otras técnicas tratan de buscar límites del objeto usando la detección del borde o propiedades basadas en el gradiente de la imagen, luego usan esta información para tratar estas áreas separadamente.

Superficies transparentes o reflectoras: Los objetos que son parcialmente transparentes plantean un problema para la tarea de recobrar el flujo óptico. El flujo de la escena de la imagen exhibirá movimientos múltiples en puntos correspondiente a objetos transparentes (uno del objeto parcialmente transparente y los otros proviniendo de objetos que se miran a través del objeto transparente). Esta situación contrasta con el problema previo (los objetos ocluyendo o apareciendo), donde tenemos movimientos múltiples en un barrio, no en cada punto. Los objetos reflectores también resultan en movimientos múltiples, un movimiento que describe el objeto que refleja y otro movimiento que describe la imagen reflejada.

Erosión La transformación morfológica de la erosión  combina dos conjuntos utilizando la substracción de vectores.



X  B  d  E2 : d  b X

para cada



bB

El ejemplo de la Figura B representa el proceso de erosión para la imagen X por el operador B [10].

X  (0,2), (1,2), (2,0), (2,1), (2,2), (2,3), (3,2), (4,2) B  (0,0), (0,1) X  B  (2,0), (2,1), (2,2)

37


 0 0  1  0  0

0 1 0 0  0  0 0 1 0 0  1 1 1 0   1 1   1   0 1 0 0 0  0 0 1 0 0

0 0 0 0 0 0 0 0 1 1 0 0  0 0 0 0 0 0 0 0

Figura 4.2. Erosión con un operador de un solo renglón y dos columnas. En la erosión el proceso grafico puede describirse de la siguiente manera, se realiza un barrido de la imagen de izquierda a derecha y de arriba hacia abajo, cuando se localiza un 1, el operador se cuadra tomando como referencia el punto representativo, si todos los unos del elemento estructural coinciden con unos en la imagen original el punto analizado se marca como 1, en caso contrario se marca como 0.

Figura 4.3. Imagen erosionada.

Dilatación La transformación morfológica de la dilatación  combina dos conjuntos utilizando la adición de vectores. Es necesario aclarar que la dilatación y la erosión no son operaciones invertibles, pues la información perdida durante el proceso de erosión o dilatación no puede ser recuperada con otra operación morfológica. La dilatación de X con el operador B es el conjunto de puntos de todas las posibles adiciones vectoriales de pares de elementos, uno de cada conjunto de X y B [10].



X  B  d  E2 : d  x  b

para cada

x X

y



bB

La Figura D ilustra el siguiente ejemplo de dilatación. Ejemplo:

38


X  (0,1), (0,2), (1,2), (2,0), (2,4), (3,2), (3,3) B  (0,0), (0,1) X  B  (0,1), (0,2), (0,3), (1,2), (1,3), (2,0), (2,1), (2,3), (2,4), (3,2), (3,3), (3,4)  0 0  1  0  0

1 1 0 0  0  0 0 1 0 0  0 0 1 0   1 1   1   0 1 1 0 0  0 0 0 0 0

1 1 1 0 0 1 1 0 1 0 1 1  0 1 1 1 0 0 0 0

Figura 4.4. Dilatación con un operador de un solo renglón y dos columnas. Gráficamente la operación de dilatación consiste en barrer de izquierda a derecha y de arriba hacia abajo la matriz X, en las posiciones con valor 1 se coloca el operador B con origen en el punto representativo y los valores abarcados por la estructura se sustituyen por los indicados en ella. En el ejemplo mostrado en la Figura D, la cantidad de columnas y filas se conserva debido a la forma del operador y a que la imagen original no contiene 1 en la ultima columna, pero se pueden dar casos como el mostrado en la Figura 4.5 donde la cantidad de columnas y filas aumenta por las condiciones de la imagen original y del operador morfológico.

 0 0  0  0  0

0 1 0 0 0  0   0 1 0 0  1 0  0 1 1 0 0      1 1  0 1 1 0 1 0 0 0 0 1   0

1 0 0 0 0 1 1 0 0 0 1 1 1 0 0  1 1 1 1 0 1 1 1 1 1  0 0 0 1 1

Figura 4.5 Dilatación con un operador en forma de L.

Figura 4.6. Imagen con dilatación.

39


Operador de Sobel El operador Sobel es un método utilizado en detección de bordes, aplicándolo sobre una imagen digital en escala de grises, calcula el gradiente de intensidad de brillo de cada pixel dando la dirección del mayor incremento posible (de negro a blanco), el resultado muestra que tan abruptamente cambia una imagen en cada punto analizado. El operador consiste de dos matrices de convolución, una para los contornos horizontales y otra para los contornos verticales. Uniendo los resultados de las matrices es posible encontrar una resultante. Matriz de Sobel. Contornos eje X

Matriz de Sobel. Contornos eje Y

Resultante =

40

CAPITULO

41

CAPITULO

CAPITULO 5 PROBLEMÁTICA A RESOLVER La elección del lenguaje de programación y del sistema operativo El interés por crear aplicaciones para dispositivos móviles ha aumentado en la misma medida que estos han demostrado su funcionalidad. Además, con el aumento en las capacidades de procesamiento de estos dispositivos se ha abierto todo un abanico de posibilidades de aplicación de los mismos. Sin embargo, cuando se considera elaborar aplicaciones para dispositivos móviles, la principal dificultad que se debe enfrentar es la elección de una plataforma de desarrollo, como es la metodología de análisis el diseño de sistemas, el lenguaje de programación, sistema operativo sobre el que se trabaja, etc.

SO móvil

Android

Symbian

MAEMO

iPhone OS

Window s Phone 7

Servicios de Comunicación Infrarrojo Bluetooth Wireless

x

√

x

Cámara

Market

Procesador

Lenguaje

Año

Open Source

√

√

1GHz

Java

2007

√

2007

√

x

x

x

x

x

1GHz

C++, Java, Ruby, Perl y Python

x

x

x

x

√

ARM Cortex A8 600 MHz

C++ y Python

2005

√

x

x

x

√

√

Doble núcleo 800 MHz

Objectiv e–C

2007

√

x

x

x

√

√

1GHz

C#

2010

√

Tabla 5.1. Comparativa de los sistemas operativos móviles

42

CAPITULO Propuesta de solución

Problemática a resolver

A partir de un análisis cuidadoso considerando las restricciones propias de un dispositivo móvil, la correcta aplicación de la plataforma elegida redundará en un proceso de desarrollo más eficiente, rápido, económico y con aplicaciones más robustas. En esta tesis se analizará una donde se estudio la capacidad del dispositivo móvil como herramienta para procesamiento de imagen. Dado que actualmente son pocas la aplicaciones de software que nos permitan tener el control visual mediante un dispositivo móvil, aprovecharemos el ambiente multiplataforma que proporciona un dispositivo móvil. Tenemos a nuestro favor que estos dispositivos tienen la capacidad de procesar la captura de imagen en tiempo de ejecución, gracias a los procesadores que están manejando. Además el mercado de los dispositivos móviles se abarata rápidamente esto nos dará como ventaja poder obtenerlo fácilmente.

Características de la solución La arquitectura propuesta es “Mobile Visual System” se propone un modelo modelo multiplataforma que se adapta a nuevos algoritmos de visión artificial con el fin de ser probados en un dispositivo móvil. Algunas de sus ventajas -

Se descargara vía Market.

-

El modelo será código abierto.

-

Es un medio externo de comunicación el control visual.

-

Se podrá tener un mejor control del hardware del dispositivo móvil al utilizar un inhabilitador que dé prioridad a la aplicación a ejecutar.

43

CAPITULO

44

CAPITULO

CAPITULO 6 DESCRIPCION DE LA SOLUCION Modelo propuesto. La arquitectura “Mobile Visual System” contempla varios requerimientos de importancia tales como seleccionar la comunicación a la cual se tendrá acceso, debemos contar con un controlador de medios para garantizar la finalización de nuestra aplicación una vez que se ejecuta, trabajar con el configurador para adaptar las necesidades del software del dispositivo móvil, tener el control de la cámara para hacer la aplicación de los algoritmos seleccionados y finalmente una interfaz grafica amigable para su utilización.

6.1 Arquitectura VMS

45

Descripción de la solución CAPITULO

Componentes La arquitectura VMS está constituida por 5 partes comunicación remota, controlador de medios, configurador, interfaz grafica y cámara. Aquí una breve descripción de cada componente a) Comunicación Remota 1. Infrarrojo Es una red que consigue la comunicación entre dos dispositivos a través de ondas infrarrojas. La red por infrarrojos necesita dos componentes, un emisor y un receptor, para realizar la transmisión de información. Para que dicha transmisión se lleve a cabo se deben de cumplir tres requisitos básicos: ser visibles entre sí, estar muy cerca y estar alineados para que sus respectivos leds infrarrojos estén enfrentados. Esto limita a este tipo de redes para realizar sólo intercambios de información a muy poca distancia. Las ondas infrarrojas no pueden atravesar las paredes, y son lentas. 2. Bluetooth Es un estándar global reconocido por los líderes en los sectores de telecomunicaciones, la lista de dispositivos compatibles aumenta constantemente. Las aplicaciones de Bluetooth son casi infinitas y permiten cambiar radicalmente la forma en la que los usuarios interactúan con los teléfonos móviles y otros dispositivos. Permite comunicación en distancias de hasta 10 metros aproximadamente. En los dispositivos móviles la sincronización con una computadora implica poder compartir la libreta de direcciones, calendarios, lista de tareas pendientes, etc. sin tener que conectarse mediante un cable. 3. Wireless El router inalámbrico más popular es el WiFi por ser el más utilizado para acceder a Internet desde cualquier lugar donde haya un punto de acceso, es el dispositivo que reúne el conjunto de estándares para la WLAN es una frecuencia de radio desarrollado por el IEEE y la mayoría de los sistemas dispositivos móviles de ultima generación lo soportan.

46


4. Web Service Colección de protocolos y estándares que sirven para intercambiar datos entre aplicaciones, son los elementos fundamentales en la evolución hacia la computación distribuida a través de Internet. Se están convirtiendo en la plataforma de integración de aplicaciones gracias a los estándares abiertos y al énfasis en la comunicación y colaboración entre personas y aplicaciones. Las aplicaciones se crean utilizando los diversos Web Services que funcionan conjuntamente, sin importar su ubicación o la forma en que se implementaron. b) Controlador de Medios Este controlador contara con un Inhablilitador de servicios internos del dispositivo móvil como pueden ser recepción de llamadas, alarmas o notificaciones. El objetivo es que este Inhabilitador permita terminar las aplicaciones ejecutadas evitando así la perder información que puede propiciar un mal resultado en las pruebas.

c) Configurador Por medio del configurador el usuario podrá determinar la secuencia de acciones que tendrá la aplicación móvil, es decir, atreves de este modulo se crean los pasos para configurar el medio de envío de datos por la comunicación remota seleccionada (bluetooth, infrarrojo, etc), y así aplicar un conjunto de acciones, de visión por computadora, para cada imagen o todas las imágenes seleccionadas, sin necesidad de cambiar la logística de la aplicación independientemente de la plataforma que se allá seleccionado.

d) Interfaz Grafica Manejador de Eventos. Un evento es un objeto que representa un evento de usuario. Un objeto evento puede encapsular el estado relacionado con un evento de usuario, como los toques asociados. Cuando un evento de usuario se lleva a cabo por ejemplo, cuando los dedos tocan la pantalla y se mueven sobre la superficie- el sistema envía constantemente objetos de eventos a una aplicación para su procesado.

e) Cámara - Video Es un sistema de grabación procesamiento, almacenamiento, transmisión y reconstrucción por medios electrónicos digitales o analógicos de una secuencia de imágenes que representan escenas en movimiento que pueden estar acompañadas de sonidos actualmente el término hace

47


referencia a distintos formatos. La calidad del video estará determinada por distintos factores, como el método de captura.

-

Imagen Representación visual que manifiesta la apariencia visual de un objeto real o imaginario. La imagen está construida por una gran cantidad de cuadros, llamados pixel los cuales están rellenos de un color uniforme.

-

Visión por computadora Es la técnica que tiene como propósito la programación de algoritmos para que por medio de imágenes o videos la computadora pueda entender una escena o las características de una imagen. Algunos de los objetivos que tiene este campo de la inteligencia artificial pueden ser la detección, segmentación, localización y reconocimiento de ciertos objetos en imágenes o el seguimiento de un objeto en una secuencia de imágenes por mencionar algunas. A continuación haremos una reseña de algunos componentes de esta materia. o

Erosión La erosión disminuye el tamaño de los objetos y la forma en que se produce esta disminución depende del elemento estructural elegido.

o

Dilatación En general, la dilatación aumenta el tamaño de un objeto. La cantidad y la forma en que aumenta el tamaño dependen de la elección del elemento estructural.

o

Escala de grises Utiliza matices de negro para representar objetos. Los objetos en escala de grises tienen un valor de brillo comprendido entre el 0% (blanco) y el 100% (negro). Las imágenes producidas con escáner de blanco y negro o de escala de grises se visualizan normalmente en escala de grises.

o

Imagen binaria Una imagen binaria es una función de dos variables discretas a[m,n] que puede tomar dos valores, „0‟ o „1‟, dependiendo del nivel de gris de la imagen (una imagen binaria tiene dos niveles: blanco y negro).

48


o

Sobel El operador Sobel se aplica fundamentalmente para determinar los contornos de una imagen; pertenece al grupo de herramientas de detección de bordes que se usan para reconocimiento de imágenes.

6.1 Requerimientos funcionales y no funcionales Requerimientos de procesos son la especificación de los estándares de calidad que se deben utilizar en el proceso, una especificación que el diseño debe producir con una herramienta CASE particular y una descripción del proceso a seguir. Los requerimientos se especifican a usuarios del sistema los conocimientos técnicos del sistema. [11] Las características que los requerimientos deben tener:     

Especificar en lenguaje natural Expresarse de forma individual Organizarse de forma jerárquica Deben ser claros, concretos y concisos Deben de indicar lo que se espera que haga el sistema, su justificación y, en su caso, los criterios de aceptación que sean aplicables.

Por su naturaleza los requerimientos se dividen en dos categorías: o

Requerimientos funcionales. Son declaraciones de los servicios que debe proporcionar el sistema, de la manera en que éste debe reaccionar a entradas particulares y de cómo se debe comportar en situaciones particulares. En algunos casos, los requerimientos funcionales de los sistemas también pueden declarar explícitamente lo que el sistema no debe hacer. Los requerimientos funcionales de un sistema describen lo que el sistema debe hacer. Estos requerimientos dependen del tipo de software que se desarrolle, de los posibles usuarios del software y del enfoque general tomado por la organización al redactar requerimientos. Cuando se expresan como requerimientos del usuario, habitualmente se describen de una forma bastante abstracta. Sin embargo. Los requerimientos funcionales del sistema describen con detalle la función de éste, sus entradas y salidas, excepciones, etcétera. Los requerimientos funcionales para un sistema software se pueden expresar de diferentes formas.

49


o

Requerimientos no funcionales. Son restricciones de los servicios o funciones ofrecidos por el sistema. Incluyen restricciones de tiempo, sobre el proceso de desarrollo y estándares. Los requerimientos no funcionales a menudo se aplican al sistema en su totalidad. Normalmente apenas se aplican a características o servicios individuales del sistema. Los requerimientos no funcionales, como su nombre sugiere, son aquellos requerimientos que no se refieren directamente a las funciones específicas que proporciona el sistema, sino a las propiedades emergentes de éste como la fiabilidad, el tiempo de respuesta y la capacidad de almacenamiento. De forma alternativa, definen las restricciones del sistema como la capacidad de los dispositivos de entrada/salida y las representaciones de datos que se utilizan en las interfaces del sistema.

Requerimientos Funcionales Aquí algunos de los requerimientos funcionales considerados del modelo VMS

Enviar datos

Descubrir servicios Web

Seleccionar secuencia de datos

Guardar video

Iniciar captura de video

Habilitar servicios

Guardar imagen

Detener captura de video

Abrir cámara

Verificar estados de un servicio

Validar algoritmo de visión

Agregar algoritmo de visión

Recibir datos

Ubicación de componentes visuales

Crear componentes visuales

Establecer formato de imagen -PNG -JPG -Formato nativo del sistema operativo móvil

Aplicar algoritmo -Escala de grises -Imagen binaria -Aplicar dilatación -Aplicar erosión -Aplicar Sobel

Seleccionar tipo de comunicación -Elegir velocidad -Habilitar puertos

Vincular eventos con componentes visuales -Eventos de teclado -Pantalla táctil

Figura 6.2 Requerimientos funcionales del sistema

50


Requerimientos no Funcionales Los requisitos no funcionales describen cualidades del sistema que no se relacionan directamente con su funcionamiento, aunque son importantes en el contexto de uso de la aplicación. Se definen las propiedades y restricciones del sistema a construir o sobre el proceso que lo construirá.

Habilitar servicio

Buscar servicio

Recibir datos

Mostrar resultados

Verificar archivo valido

Abrir cámara

Seleccionar foto

Aplicar algoritmo

Leer instrucción

Figura 6.3 Requerimientos no funcionales del sistema

Casos de Uso Un caso de uso representa una unidad funcional coherente de un sistema, subsistema o clase. Es una operación/tarea específica que se realiza tras una orden de algún agente externo, sea desde una petición de un actor o bien desde la invocación desde otro caso de uso. [11] Una forma de describir los requisitos iniciales del usuario, durante la fase de conceptualización, es construir casos de uso del sistema, descritos inicialmente por Jacobson en 1987 y actualmente incorporados a la mayor parte de las metodologías de Análisis Orientado a Objetos. [11] Un caso de uso está formado por una serie de interacciones entre el sistema y un actor (una entidad externa, ejerciendo un rol determinado), que muestran una determinada forma de utilizar el sistema. Cada interacción comienza con un evento inicial que el actor envía al sistema y continua con una serie de eventos entre el actor, el sistema y posiblemente otros actores involucrados. Un caso de uso puede ser descrito en lenguaje natural, mediante trazas de eventos o mediante diagramas de interacción de objetos.

51


Elementos de un modelo de casos de uso: 

Actores. Un actor es una agrupación uniforme de personas, sistemas o máquinas que interactúan con el sistema que estamos construyendo de la misma forma. Los actores son externos al sistema que vamos a desarrollar. Por lo tanto, al identificar actores estamos empezando a delimitar el sistema, y a definir su alcance. Definir el alcance del sistema debe ser el primer objetivo de todo analista, ya que un proyecto sin alcance definido nunca podrá alcanzar sus objetivos.



Casos de uso. Es una secuencia de interacciones entre un sistema y alguien o algo que usa alguno de sus servicios. Todo sistema de software ofrece a su entorno –aquellos que lo usan– una serie de servicios.



Relaciones. Representan una parte de la funcionalidad del caso que no siempre ocurre.

Para el análisis del sistema VMS, consideramos los casos de uso más relevantes. A continuación se hará un pequeño análisis de ellos. Se hizo una pequeña clasificación dada la naturaleza de los casos de uso. Primeramente todas las tareas relaciones con la transformación de la imagen están relacionadas con visión artificial es necesario hacer una validación de algoritmo con el fin cumplir el objetivo

52


La verificación de la cámara es fundamental a partir de ahí es que el usuario puede iniciar el proceso de modificación de la imagen. Aquí es donde inicia la captura y envió de imagen o imágenes. Validar algoritmo de vision


Seleccionar secuencia de pasos

Recibir datos

Enviar datos

Crear componentes visuales

Descubrir servicios Web

Ubicacion de componentes visuales

Usuario Detener captura de video

Guardar video

Figura 6.4. Casos de uso del sistema 1 La comunicación que tendrá el dispositivo es otra parte importante del proceso, una vez selecciona la imagen o imágenes a procesar es necesaria la sección del medio por el cual se hará la comunicación. Habilitar Servicios Elegir Velocidad

Abrir camara Seleccionar tipo de comunicacion Habilitar puertos

Verificar estatus de un servicio

Guardar imagen

png

«uses»

Usuario

Establecer formato de la imagen

«uses» «uses»

Abrir camara

Formato nativo del sistema operativo

jpg

Figura 6.5. Casos de uso del sistema 2

53


Finalmente la aplicación de algoritmos que nos permitirá la aplicación correcta de visión artificial.

Elegir Velocidad

Elegir plantilla de incorporacion

Habilitar puertos

«uses» «uses» Aplicar algoritmo


Aplicar Dilatacion

«uses» «uses»

Escala de grises

«uses»

Vincular eventos con componentes visuales

Usuario

Eventos teclado

Aplicar sobel

«uses»

Seleccionar tipo de comunicacion

Agregar algoritmo

Pantalla tactil

Imagen Binaria

Aplicar erosion

Figura 6.6. Casos de uso del sistema 3

Estos son los casos de uso más relevantes en el modelo propuesto y a continuación se harán una reseña de los 4 más importantes: -

Habilitar servicios

-

Aplicar algoritmos

-

Validar algoritmos

-

Enviar datos

54


A continuación una breve reseña de la importancia de cada uno de ellos. Habilitar servicio, esto nos permitirá la comunicación vía Infrarrojo, Bluetooth, Wireless o Web Service según la selección del usuario, en la tabla 6.1 las especificaciones de este caso de uso. Nombre del caso de uso Cuando inicia el caso de uso Cuando terminar el caso de uso Precondiciones del caso de uso

Habilitar servicios Cuando el usuario da click en el botón Cuando el modulo se ha cerrado correctamente Tener configurados los servicios (Infrarrojo, Bluetooth, Wireless, Web Service) Post condiciones del caso de uso Efectuar los cambios seleccionados para cada servicio Relación con otros casos de uso Ninguno Relación con otros actores Ninguno Acciones - Mostrar los servicios instalados en el dispositivo móvil - Permitir la selección de cada servicio para habilitar o no (es decir establecer porque medio se habilitara el envió de información) Tabla 6.1. Casos de Uso: Habilitar servicios

Aplicar algoritmos, una vez selecciona la imagen o imágenes a procesar será necesaria la aplicación una secuencia de algoritmos previamente seleccionadas. Nombre del caso de uso Cuando inicia el caso de uso Cuando terminar el caso de uso

Aplicar algoritmos Seleccionar la o las imágenes para aplicar algoritmo Cuando se aplico correctamente el algoritmo de visión al conjunto de imágenes. Precondiciones del caso de uso La imagen debe estar en formato JPG o PNG Post condiciones del caso de uso - La aplicación correcta a cada imagen usando el algoritmo de visión seleccionado. - No haber modificado la imagen o las imágenes original(s). Relación con otros casos de uso Ninguno Relación con otros actores Ninguno Acciones - Seleccionar la imagen o las imágenes requeridas - Aplicar uno o varios algoritmos de visión artificial para cada imagen - Generación de una nueva imagen como resultado del paso anterior. Tabla 6.2. Casos de Uso: Aplicar algoritmos

55


Validar algoritmos, esto es una vez seleccionado el algoritmo a aplicar, verificar que el resultado sea satisfactorio y generar nuevas imágenes a partir de las originales. Nombre del caso de uso Cuando inicia el caso de uso

Validar algoritmos Cuando el usuario da clic en el botón de procesar imagen. Cuando terminar el caso de uso Una vez que termina el proceso de explicación para todas las imágenes albergadas. Precondiciones del caso de uso - Tener un conjunto de imágenes a procesar - Tener definido previamente secuencia de acciones que se aplicara a cada imagen - Contar con memoria RAM para realizar la tarea Post condiciones del caso de uso - El no indicar la presencia de errores durante el tratamiento de las imágenes - No modificar las imágenes originales Relación con otros casos de uso Ninguno Relación con otros actores Ninguno Acciones - Obtener la secuencia de acciones a procesar para cada imagen - Tener por lo menos una imagen para procesarla - Aplicar el algoritmo a cada imagen - Verificar si fue correcta la aplicación del algoritmo en la imagen Tabla 6.3. Casos de Uso: Validar algoritmos Enviar datos. Una vez procesada la imagen hay que regresar una respuesta a la interfaz grafica como resultado. Nombre del caso de uso Cuando inicia el caso de uso Cuando terminar el caso de uso Precondiciones del caso de uso

Post condiciones del caso de uso

Relación con otros casos de uso Relación con otros actores Acciones

Enviar datos Una vez que fue seleccionada dicha imagen Cuando se envía la información al brazo robótico - Tener una imagen para ser procesada (como mínimo contar con un medio activo de envió de datos). - Haber aplicado correctamente al algoritmo de visión seleccionado. - Haber enviado la información sin haber sido modificada - Cerrar el canal de comunicación Ninguno Ninguno - Abrir el canal de comunicación - Verificar si el servicio está activo

56


Enviar el conjunto de imágenes al servicio Notificar que se ha terminado de enviar la información. Tabla 6.4. Casos de Uso: Enviar datos -

Análisis y Diseño (UML) Una vez propuesta nuestra alternativa para resolver la problemática antes citada, se debe especificar correctamente como se deberá de implementar en un lenguaje de programación en concreto. Para lograr dicha acción es necesario usar una metodología denominada: Unified Modeling Language "UML", se ha convertido en la notación estándar para definir, organizar y visualizar los elementos que configuran la arquitectura de un sistema. Un sistema es algo "compuesto", una construcción realizada por manos y herramientas siguiendo las directrices de un propósito. La palabra se aplica casi exclusivamente a abstracciones con el fin de captar la totalidad de una realidad. A través de la notación UML podemos comunicar y compartir el conocimiento de una arquitectura gracias a la combinación simultánea de cinco perspectivas: 1. Definir. Fijar, determinar, decidir, explicar un concepto a través de sus atributos distintivos. Señalar sus límites y dar una idea exacta de lo que es esencial y de lo que es circunstancial. 2. Organizar. Establecer unos recursos, disponer un orden de responsabilidades y formalizar unas reglas de relación y actuación; todo ello orientado a conseguir un propósito. 3. Visualizar. Representar mediante imágenes y/o símbolos el contenido y la organización de los conceptos que configuran un sistema. Hacer visible su naturaleza y su complejidad. 4. Actuar. Pensar y tomar decisiones de manera ágil y sistemática, siguiendo un método; éste a su vez, define el modo de actuar en base a la relación de un conjunto de actores, actividades, entregables y certificaciones posibles en un escenario concreto. 5. Certificar. Comprobar de manera fehaciente que un entregable es completo, coherente y usable para el propósito que ha sido creado.

57


En base a un análisis UML, aquí haremos un análisis de algunas de las características de nuestro sistema.

Habilitar servicios Esta parte de nuestro diseño es la encargada de habilitar el servicio de comunicación que se aplicara en nuestra aplicación a continuación haremos un análisis grafico de este.

Servicios

-Infrarrojo : int = 1 -Bluetooth : int = 1 -Wireless : int = 1 -Web Service : int = 1 #buscarServicios (int i); Object [ ]() #estarActivo (Object a); Boolean() #apagar (Object a); Boolean accion() #listado ( ); Boolean [ ]() #recibeDato (Object a);()

Habilitador

-TRUE : int = 1 -FALSE : int = 0 #habilita (Object a, Boolean accion)() Figura 6.7 Diagrama de clases: Habilitar Servicios

58


Interfaz Grafica

Servicios

Habilitador

Habilitar Servicios

buscarServicios( )

Mostrar Información

Listado( )

recibeDato( )

Usuario

habilita

Éxito

Figura 6.8 Diagrama de actividades: Habilitar Servicios

: Interfaz Grafica

: Servicios

: Habilitador

Habilitar Servicio Buscar Servicio Mostrar

Usuario Seleccionar elemento

Listado( )

recibeDato( ) Mostrar resultado

Habilita object( )

Figura 6.9 Diagrama de secuencia: Habilitar Servicios

59


7 Mostrar resultado

1 habilitarServicio()

Usuario

: Interfaz Grafica

2 buscarservicios

4 mostrar datos

: Servicios

3 listado ()

5 recibeDato

6 habilita object()

: Habilitador

Figura 6.10 Diagrama de colaboración: Habilitar Servicios

Aplicar algoritmos

Configurador -Imagen : Object #leerDatos() : Object

Foto #seleccionarFoto();() : object

Vision #aplicarAlgoritmo() : Object Figura 6.11 Diagrama de clases: Aplicar Algoritmos

60


:

conf Configurador 1. leerDatos()

:

Usuario

foto Foto 1.1 seleccionaFoto()

:

v Vision 1.1.1 aplicaAlgoritmo()

Figura 6.12 Diagrama de actividades: Aplicar Algoritmos

:

conf Configurador

1.1selecuonaFoto()

:

foto Foto

:

v Vision

1.1.1 aplicaAlgortimo()

1. leerDatos() Usuario

Figura 6.13 Diagrama de secuencia: Aplicar Algoritmos

61

Descripción de la solución CAPITULO Usuario Leer configuración

Seleccionar imagen

Aplicar configuracion

Si

No Es exitoso

Informe de error

Fin

Figura 6.14 Diagrama de colaboración: Aplicar Algoritmos

Validar algoritmos Configurador -Imagen : Object #leerDatos() : Object

Foto #seleccionarFoto() : object

Vision #aplicarAlgoritmo() : Object

Analizador #escorrecto() : Object

Figura 6.15 Diagrama de clases: Validar Algoritmos

62

CAPITULO Descripción de la solución

:


:

Usuario


:


: Analizador

ana

1.1.1.1 esCorrecto()

Figura 6.16 Diagrama de actividades : Validar Algoritmos

:

conf Configurador

1.1selecuonaFoto()

:

foto Foto


:

v Vision

ana

: Analizador



Figura 6.17 Diagrama de secuencia: Validar Algoritmos

63

Descripción de la solución CAPITULO Usuario Leer configuración

Seleccionar imagen Si

No Escala de grises

Aplicar algortimo Si

No Es exitoso

Informe de error Fin

Figura 6.18 Diagrama de colaboración: Validar Algoritmos

Enviar datos Servicios

-Infrarrojo : int = 1 -Bluetooth : int = 1 -Wireless : int = 1 -Web Service : int = 1 #buscarServicios (int i); Object [ ]() #estarActivo (Object a); Boolean() #apagar (Object a); Boolean accion() #listado ( ); Boolean [ ]() #recibeDato (Object a);()

Habilitador

-TRUE : int = 1 -FALSE : int = 0 #habilita (Object a, Boolean accion)()

Figura 6.19 Diagrama de clases: Enviar Datos

64


:


:

Usuario


:


: Analizador

ana


Figura 6.20 Diagrama de actividades : Enviar Datos

:

conf Configurador

1.1selecuonaFoto()

:

foto Foto


:

v Vision

ana

: Analizador



Figura 6.21 Diagrama de secuencia: Enviar Datos

65

Descripción de la solución CAPITULO Usuario Seleccionar fotos Si

No Aplicar algoritmo

Vision algoritmo

Si

No Es solo una amagen

Comprimir datos

Convertir binario Si

No Servidor WEB

Buscar medio

Enviar datos Fin

Figura 6.22 Diagrama de colaboración: Enviar Datos

66

CAPITULO

67

CAPITULO

CAPITULO 7 CONCLUSIONES Y TRABAJO FUTURO Conclusiones Como hemos observado a lo largo de esta investigación, nuestro trabajo proporcionó una gran cantidad de resultados, factibles y buenos, debido a que se analizó por un determinado tiempo todo lo involucrado con la programación móvil, lo que originó la creación de una arquitectura que se adaptara a la mayoría de los dispositivos móviles, para incorporar procesos de visión computacional en un controlador visual, para el procesamiento de información y con esto ayudar a que el controlador visual realice otras tareas mas demandantes. El trabajo realizado generó los siguientes resultados:  





Un prototipo funcional, basado en nuestra arquitectura, el cual cumplió con todas las expectativas de diseño, de pruebas y de uso. Las limitaciones del dispositivo móvil, se plasmaron en la propuesta de la arquitectura, lo cual permitió constatar que las consideraciones realizadas estuvieron bien diseñadas. La incorporación de nuevos algoritmos de visión, basados en una plantilla propuesta, aseguro que la adición de estas acciones no alteran la estructura principal del programa principal. La implementación mejorada para los algoritmos de conversión de imagen binaria y de escala de grises.

El trabajo exhibido, en este documento, demuestra la labor realizada por más de un año, para su realización y culminación, tiempo en el cual fue necesario estudiar las arquitecturas de cada sistema operativo, así como el determinar las ventajas y las desventajas de cada uno. Dicha finalidad permitió crear una solución que adopte, incorpore o utilice las características de un determinado dispositivo móvil. También se complemento, las deficiencias presentadas en cada sistema móvil para tratar de ser sustituidas por alguna otra solución. Un claro ejemplo puede observarse en el Windows Phone, durante el desarrollo del prototipo, por que no posee un proceso de comunicación como bluetooth o señal infrarroja, así que se utilizó la comunicación a través de Internet (la cual esta expuesta en la arquitectura como medio de comunicación).

68

Conclusiones y trabajo futuro CAPITULO

Esta labor permitió considerar otras mejoras, que se pueden incrementar las bondades de esta alternativa de solución pero, éstas nuevas particulares serán mencionadas en el siguiente capitulo.

Trabajo futuro Durante el desarrollo del prototipo, así como reuniones entre asesores de este trabajo, se obtuvieron comentarios enriquecedores que pueden ser considerados en un futuro cercano, para ser incorporados en ésta tesis. A continuación, se presenta algunas agregaciones: 1. La incorporación de un sistema inteligente para detectar cambios de escenarios, utilizando diferentes algoritmos de visión computacional, y seleccionar la mejor opción para ser enviada al control visual. 2. El uso del multiprocesamiento, debido a que los dispositivos móviles están incorporando varios procesados en un solo chip, será conveniente crear un patrón de diseño, para dividir dichas actividades y aprovechar al máximo los recursos del dispositivo.

3. Habilitar una bi-comunicación entre el dispositivo móvil y el control visual, por que sólo el dispositivo móvil envía datos al control visual, pero si existiera una comunicación bi-direccional entre los dos, ambos pudieran mejorar sus tareas, por ejemplo: si la cámara detecta la presencia de algo, tomando como referencia un ángulo de 180 grados, después envía la información al control visual y éste le solicita, posteriormente, girar la cámara 45 grados más, para determinar si hay un obstáculo o esta libre, para continuar con su trayecto. Estas gestiones serán útiles para la toma de decisiones. 4. Crear un algoritmo para seleccionar aquellas imágenes que poseen un cambio de movimiento, por que la cámara captura las imágenes, cada imagen es guardada y es procesada, entonces el tiempo de procesamiento por una hora de trabajo continuo seria excesivo y repetitivo. Surge entonces, la idea de mejorar el proceso antes citado.

69

CAPITULO

70

CAPITULO

APÉNDICE 1 IMPLEMENTACIÓN EN LA PLATAFORMA WINDOWS PHONE 7 En este capítulo se explicarán algunas aplicaciones desarrolladas en la plataforma de Windows Phone 7, desde aplicaciones sencillas hasta las implementaciones realizadas en el procesamiento digital de imágenes requeridas para diseños robóticos. Para implementar el desarrollo de imágenes es necesario implementar la programación con multimedia. En el ambiente de la plataforma para el dispositivo WP7la multimedia incluye tanto imágenes como audio, vídeo y animación, en este capítulo abordaremos los temas correspondientes a imágenes y vídeo, para ello nos basaremos en las API‟s del WP7 que proporcionan una manera muy sencilla de interactuar con las funciones multimedia de este dispositivo. En Windows Phone podemos encontrar dos frameworks claramente diferenciados: Silverlight para Windows Phone y XNA para Windows Phone. 



Silverlight for Windows Phone es un framework basado en Silverlight que nos permitirá crear aplicaciones multimedia ricas que se ejecuten de forma nativa en Windows Phone, con una interface creada en XAML. XNA for Windows Phone a su vez se basa en XNA para Windows, se trata de una solución Multiscreen (Xbox, Windows, Windows Phone) 2D y 3D para crear juegos con calidad profesional en el dispositivo.

Aplicaciones en WP7 En Windows Phone las aplicaciones se despliegan en forma de paquete XAP, básicamente es un archivo comprimido dentro del cual podemos encontrar los ensamblados y recursos originales de nuestra aplicación. La única forma de instalar una aplicación en Windows Phone es mediante la tienda oficial de Microsoft, El Marketplace, en la cual debemos registrarnos como desarrolladores para poder vender nuestras aplicaciones. Para garantizar la seguridad del sistema y evitar la piratería, el malware o virus, a cada aplicación se le asigna un ID único y un certificado de seguridad emitido cuando nuestra aplicación es aprobada en el Marketplace de Windows Phone. Este certificado

71

Apéndice 1 CAPITULO

puede instalarse en modo demo, por lo que solo con comprobar el modo de este certificado desde nuestra aplicación podremos saber si nos encontramos en modo de prueba o modo completo y restringir o cambiar la forma en que nuestra aplicación se comporta, evitando el desarrollo de versiones “lite” como en otras plataformas.

Modelo de UI El modelo de interface de usuario de Windows Phone se compone de elementos, páginas y sesiones. Un elemento es todo control que se muestra al usuario, una página es una agrupación lógica de elementos y una sesión es el conjunto de interacciones que realiza un usuario sobre nuestra aplicación e incluso puede involucrar a otras aplicaciones.

Entorno de programación Una vez que hemos conocido un poco la arquitectura de hardware y software general que podemos encontrar en Windows Phone es hora de comenzar a preparar nuestro entorno de desarrollo, para ello vamos a dar un repaso a las herramientas que Microsoft pone a nuestra disposición de forma gratuita para poder crear aplicaciones para la plataforma.

Descargando el SDK Para comenzar a desarrollar aplicaciones en Windows Phone necesitaremos descargar desde la web de Microsoft el Kit de Desarrollo de Software (SDK por sus siglas en ingles Software Development Kit) que incluye todas las herramientas que podemos necesitar para crear una aplicación para Windows Phone:     

Microsoft Visual Studio 2010 para Windows Phone Microsoft Expression Blend para Windows Phone Emulador de Windows Phone Application Deployment Windows Phone Developer Registration

Una vez que hayamos descargado las herramientas, el proceso de instalación es muy sencillo.

72


Figura 8.1 – El propio instalador se descargará el software necesario. Una vez terminada la instalación debemos descargarnos las últimas actualizaciones de las herramientas de desarrollo que además de corregir bugs añaden las siguientes herramientas: 

WPConnect: Windows Phone Connect nos permitirá depurar aplicaciones en un dispositivo físico sin tener el software Zune de sincronización activado, anteriormente, al intentar depurar aplicaciones que hiciesen uso de las APIs de sensores teniendo Zune iniciado (indispensable para la depuración en dispositivos) se producía una excepción de seguridad, por lo que con esta herramienta podremos ejecutar y depurar este tipo de aplicaciones.



CapDetect: Capability Detection Tool nos permitirá detectar las capacidades especiales del teléfono que requiere nuestra aplicación (como conexión a datos o localización) y reemplazar las creadas por defecto, todo ello sin tener que editar manualmente los archivos de configuración.

Microsoft Visual Studio 2010 para Windows Phone Una vez instalado el SDK de Windows Phone 7 y sus actualizaciones tendremos a nuestra disposición todo el software necesario para desarrollar aplicaciones comerciales para este sistema operativo. Una de las principales herramientas que usaremos en el proceso de crear nuestra aplicación será Visual Studio el entorno de desarrollo profesional de Microsoft, en su versión 2010 para Windows Phone 7, una versión totalmente gratuita (figura 5.2):

73

CAPITULO Apéndice 1

Figura 8.2 – Inicio de Visual Studio 2010 para Windows Phone 7 Desde esta ventana principal podremos crear un nuevo proyecto de Silverlight para Windows Phone 7 o XNA 4.0 para Windows Phone 7, ambos usando como lenguaje C# (figura 3), pulsando sobre el link “New Project” o en el menú File > New > Project.

Figura 8.3 – Seleccionar tipo de proyecto en Visual Studio

Disponemos de 5 tipos de proyectos diferentes en Silverlight para Windows Phone: 1. 2. 3. 4.

Windows Phone Application Windows Phone Databound Application Windows Phone Class Library Windows Phone Panorama Application

74


5. 6. 7. 8. 9.

Windows Phone Pivot Application Windows Phone 3D Graphics Application * Windows Phone Audio Playback Agent * Windows Phone Audio Streaming Agent * Windows Phone Task Scheduler Agent *

*Estos proyectos solo son compatibles con dispositivos que ejecuten la nueva versión “Mango” del sistema operativo 1. Windows Phone Application La plantilla base para toda aplicación Silverlight para Windows Phone, incluye una página por defecto con los estilos de Windows Phone, archivos de imagen para la pantalla de inicio e icono que podemos sustituir por los nuestros si lo deseamos y todo listo para ejecutar con solo pulsar F5. 2. Windows Phone Databound Application Esta plantilla es exactamente igual a la plantilla base explicada anteriormente, con el añadido de que en la página creada tenemos un listbox con una plantilla de datos simple, una carpeta SampleData con datos de ejemplo y una carpeta viewmodels con clases MVVM listas para ser usadas. Nos puede ser muy útil para ver cómo funciona el enlace a datos en Windows Phone 7 y como usar el patrón de diseño MVVM para crear aplicaciones. 3. Windows Phone Class Library Si hemos trabajado anteriormente con .NET este proyecto es bastante sencillo, se trata de un proyecto para generar una librería de clases que podamos consumir desde una aplicación Windows Phone. Tenemos que recordar que, por norma general, no podemos crear una librería de clases para WPF o Silverlight y añadirla a una aplicación Windows Phone 7, por lo que tendremos que usar este tipo de proyecto para crear una librería específica para nuestra aplicación móvil. En posteriores capítulos abordaremos la problemática de compartir código entre aplicaciones web, móviles y de escritorio gracias a una característica de Visual Studio 2010 llamada multi targeting, pero por ahora basta con decir que no podemos compartir una librería de clases entre distintas plataformas. 4. Windows Phone Panorama Application Se trata de un proyecto Windows Phone Application standard, pero se ha sustituido el contenido por defecto por un control panorama, el cual nos permite tener elementos que ocupen más que el ancho de la pantalla y poder movernos por ellos simplemente desplazándonos de derecha a izquierda, en una rueda sin fin, podemos ver ejemplos de este control en los Hubs de Windows Phone 7, como por ejemplo el de Office. 5. Windows Phone Pivot Application

75


Igual que el proyecto Panorama Application, pero en este caso sustituyendo el contenido por defecto por un control Pivot, este control se comporta de forma parecida a un control de pestañas, tenemos secciones que ocupan la pantalla y podemos navegar por ellas, pulsando sobre el título superior o simplemente desplazándonos con gestos de derecha a izquierda o viceversa. Podemos ver un ejemplo de este control en la configuración de Windows Phone 7 y en otras aplicaciones que usan tabulación para mostrar distintos datos 6. Windows Phone 3D Graphics Application Este tipo de proyecto exclusivo de Windows Phone Mango (7.5) nos permite compartir en una misma aplicación, un interface de usuario creado totalmente en Silverlight con gráficos 3D de alta calidad generados usando XNA y totalmente interactivos. De esta forma tenemos lo mejor de cada mundo, la sencillez y rapidez a la hora de generar aplicaciones de Silverlight y toda la potencia de la GPU a la hora de crear contenidos 3D y gráficos interactivos, así como animaciones complejas. 7. Windows Phone Audio Playback Agent Una de las grandes novedades de Mango, es el poder desarrollar aplicaciones que se ejecuten en segundo plano, los llamados agentes. Entre ellos tenemos este proyecto en concreto que nos permite reproducir música que se encuentre en el teléfono en segundo plano sin necesidad de tener una interface de usuario abierta y visible. 8. Windows Phone Audio Streaming Agent Este proyecto es igual al anterior, salvo en que con el Streaming Agent podremos reproducir música por medio de Streaming sin necesidad de que esta se encuentre directamente en el teléfono. 9. Windows Phone Task Scheduler Agent Este tipo de proyecto nos permite ejecutar tareas de propósito general en el teléfono en segundo plano sin necesidad de una interface de usuario. Podemos así crear tareas que se encarguen de recoger datos GPS y enviarlos a un servidor para seguir una ruta o hacer cualquier tipo de procesamiento más pesado o recurrente.

Microsoft Expression Blend 4 para Windows Phone En combinación con Visual Studio 2010, tendremos a nuestra disposición otra fantástica herramienta para crear aplicaciones Windows Phone, se trata de Expression Blend 4, pensada por y para diseñadores, nos otorgará un control sin precedentes sobre el aspecto de nuestra aplicación y facilitará muchísimo el diseño de nuestra UI, permitiéndonos a golpe de ratón definir animaciones, transiciones, personalizar plantillas de control, estilos o plantillas de datos, incluso realizar el enlace a nuestros datos de forma visual.

76

CAPITULO Apéndice 1 Emulador de Windows Phone Junto con Visual Studio 2010 y Expression Blend 4 el kit de desarrollo de Windows Phone también incluye un emulador totalmente funcional del sistema, que nos permitirá probar nuestras aplicaciones en condiciones parecidas a las que podemos encontrar en un dispositivo real (Figura 4).

Figura 8.4 – Simulación de WP7

Aplicación capturando imagen Un ejemplo en la plataforma Windows Phone 7 para capturar imágenes con la cámara del dispositivo y obtener la imagen en nuestra aplicación. Para iniciar, en Visual Studio 2010 crearemos un nuevo proyecto y seleccionamos un proyecto de tipo Windows Phone Application.

77


Figura 8.5 – Selección de aplicación en Visual Studio 2010 Una vez en el formulario de la aplicación, arrastraremos un objeto tipo Image.

Figura 8.6 – Entorno Visual Studio 2010 Se añadirá un objeto tipo Button.

78


Figura 8.7 – Agregar botón en entorno Visual Studio 2010 En el código fuente del formulario, realizamos los siguientes pasos: en un principio, declarar una variable de tipo CaptureCameraTask, adicionando también la referencia a la librería que la contiene: Microsoft.Phone.Taks.

Después de esto, en el constructor de la aplicación, debemos inicializar la instancia de la clase CameraCaptureTask, y matricular el método que manejará el evento Completed del CameraCaptureTask, el cual se activará después de capturar la imagen con la cámara del dispositivo.

79

CAPITULO Apéndice 1 La declaración y la inicialización del objeto CameraCaptureTask se debe realizar como variable de campo y en el constructor del formulario respectivamente, esto debido a que es necesario para que la imagen se pueda recuperar cuando la aplicación se recupere posteriormente a la finalización de la captura de la imagen con la cámara.

En el botón agregado se generara el método que activará en el evento click, y se agrega el código para activar la cámara del dispositivo.

Se anexara el código del método que se ejecutará para manejar el evento Completed, el cual está indicado anteriormente en el constructor.

Así se podrá ejecutar la aplicación de prueba en el emulador de Windows Phone 7

Figura 8.8 – Emulador de WP7 en Visual Studio 2010

80

CAPITULO Apéndice 1 Al seleccionar la opción de Capturar Imagen, abrirá el emulador de la cámara del dispositivo, donde podrá simular la captura de una imagen.

Figura 8.9 – Ejecución de emulador de WP7 en Visual Studio 2010 Y una vez confirmada la imagen que se toma, retorna a la pantalla de la aplicación, recuperando la imagen y viéndola en el formulario de la pantalla.

Figura 8.10 – Ejecución de emulador de WP7 en Visual Studio 2010

81

CAPITULO

82

CAPITULO

APÉNDICE 2 CODIGO FUENTE Para la probar del modelo propuesto se hizo una implementación en C# utilizando el entorno WP7.

Archivo A.CS Librerías necesarias para la generación de la aplicación using System; using System.Net; using System.Windows; using System.Windows.Controls; using System.Windows.Documents; using System.Windows.Ink; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Animation; using System.Windows.Shapes; using System.Windows.Media.Imaging; using System.Collections.Generic;

Actualiza y representa un mapa de bits por trama. public static class A { public static WriteableBitmap Complement(this WriteableBitmap binaryImage) { WriteableBitmap complement = new WriteableBitmap(binaryImage.PixelWidth, binaryImage.PixelHeight); for (int pixel = 0; pixel < binaryImage.Pixels.Length; pixel++) { if ((binaryImage.Pixels[pixel] & 0xFF) == 0) { unchecked { complement.Pixels[pixel] = (int)0xFFFFFFFF; } } else { unchecked { complement.Pixels[pixel] = (int)0xFF000000; } } } return complement; } Colección de puntos que especifican los puntos de destino de una o varias líneas rectas conectadas.

83


public static List Union(this List set, List otherset) { List union = new List(set); if (union.Count == 0) { union = new List(otherset); return union; } foreach (Point p in otherset) { bool dupFound = false; foreach (Point q in set) { if (p.X == q.X && p.Y == q.Y) { dupFound = true; break; } } if (!dupFound) { union.Add(p); } } return union; }

Colección de puntos que especifican los puntos de destino de una o varias líneas rectas se cruzan. public static List Intersect(this List set, List otherset) { List union = new List(); foreach (Point p in otherset) { foreach (Point q in set) { if (p.X == q.X && p.Y == q.Y) { union.Add(p); } } return union; } Aquí se repite un grupo de instrucciones incluidas en el bucle para cada elemento de una matriz y así recorrer en iteración una colección de elementos y obtener la información deseada.

84


public static WriteableBitmap ToBitmap(this List set, int width, int height) { WriteableBitmap bmp = new WriteableBitmap(width, height); for (int pixel = 0; pixel < bmp.Pixels.Length; pixel++) { unchecked { bmp.Pixels[pixel] = (int)0xFFFFFFFF; } } foreach (Point p in set) { if (p.X >= 0 && p.Y >= 0 && p.X < width & p.Y < height) { unchecked { bmp.Pixels[(int)(p.X + p.Y * bmp.PixelWidth)] = (int)0xFF000000; } } } return bmp; }

Define la forma de mapa, o transformar, puntos de un espacio de coordenadas a otro espacio de coordenadas. Esta asignación se describe mediante una transformación de matriz, que es una colección de tres filas con tres columnas de dobles valores. Traduce (movimientos) de un objeto en el sistema bidimensional de coordenadas xy. public static List Translate(this List set, Point translation) { List translatedSet = new List(); foreach (Point elem in set) { translatedSet.Add(new Point(elem.X + translation.X, elem.Y + translation.Y)); } return translatedSet; }

Aplica dilatación en un objeto en el sistema bidimensional de coordenadas xy. public static List Dilate(this List set, List structuringElement) { List dilatedSet = new List(); foreach (Point e in structuringElement) { List translatedSet = new List(); foreach (Point p in set) { translatedSet.Add(new Point(p.X + e.X, p.Y + e.Y));

85


} dilatedSet = dilatedSet.Union(translatedSet); } return dilatedSet; }

Aplica erosión en un objeto en el sistema bidimensional de coordenadas xy. public static List Erode(this List set, List structuringElement) { List erodedSet = new List(set); foreach (Point e in structuringElement) { List translatedSet = new List(); foreach (Point p in set) { translatedSet.Add(new Point(p.X - e.X, p.Y - e.Y)); } erodedSet = erodedSet.Intersect(translatedSet); } return erodedSet; } }

Archivo B.CS Se utilizaran las mismas librerías del archivo anterior. Comprobar para ver si una determinada cadena está presente en un diccionario con claves de cadena. public class B { Dictionary> _pixels = new Dictionary>(); public B() { } public B(B originalSet) { _pixels = new Dictionary>(originalSet._pixels); }

Determina los limites de la matriz public Rect Boundary

86

CAPITULO Apéndice 2 { get { Rect boundary = new Rect(); if (_pixels.Count == 0) { return boundary; } bool isInitialized = false; int bottom = 0; int right = 0; foreach (int y in _pixels.Keys) { if (!isInitialized) { boundary.Y = y; bottom = y; boundary.X = _pixels[y][0]; right = _pixels[y][0]; isInitialized = true; } if (boundary.Y > y) { boundary.Y = y; } if (bottom < y) { bottom = y; } foreach (int x in _pixels[y]) { if (boundary.X > x) { boundary.X = x; } if (right < x) { right = x; } } } boundary.X -= 1; boundary.Y -= 1; boundary.Width = right - boundary.X + 2; boundary.Height = bottom - boundary.Y + 2; return boundary; } }

Agrega un objeto al final de la lista public void Add(int x, int y) { List columns = new List(); if (!_pixels.ContainsKey(y))

87


{ _pixels.Add(y, columns); } else { columns = _pixels[y]; } if (!columns.Contains(x)) { columns.Add(x); } }

Quita la primera aparición de un objeto específico de IList public void Remove(int x, int y) { if (_pixels.ContainsKey(y)) { if (_pixels[y].Contains(x)) { _pixels[y].Remove(x); if (_pixels[y].Count == 0) { _pixels.Remove(y); } } } } Actualización de la Región de objeto a la unión de sí mismo y el especificado rectángulo estructura. public void Union(B otherSet) { foreach (int key in otherSet._pixels.Keys) { foreach (int col in otherSet._pixels[key]) { Add(col, key); } } } Actualización de la Región de objeto a la intersección de la misma con la especificada RectangleF estructura. public void Intersect(B otherSet)

88

CAPITULO Apéndice 2 { B intersection = new B(); foreach (int key in otherSet._pixels.Keys) { if (_pixels.ContainsKey(key)) { foreach (int col in otherSet._pixels[key]) { if (_pixels[key].Contains(col)) { intersection.Add(col, key); } } } } _pixels = new Dictionary>(intersection._pixels); } Se aplica el vector de traslación especificado a esta Matrix objeto en el orden especificado. public void Translate(int translateX, int translateY) { _pixels = new Dictionary>(B.Translate(this, translateX, translateY)._pixels); } public void Dilate(B structuringElement) { _pixels = B.Dilate(this, structuringElement)._pixels; } public void Erode(B structuringElem) { _pixels = B.Erode(this, structuringElem)._pixels; } Actualizaciones esta región objeto de la porción de la especificada RectangleF estructura que no se cruzan con este objeto Región. public void Complement() { Rect boundary = Boundary; B complement = new B(); for (int row = (int)boundary.Top; row < boundary.Bottom; row++) { for (int col = (int)boundary.Left; col < boundary.Right; col++) { if (!_pixels.ContainsKey(row)) {

89


complement.Add(col, row); } else { if (!_pixels[row].Contains(col)) { complement.Add(col, row); } } } } _pixels = new Dictionary>(complement._pixels); } Actualización de la Región de objeto a la unión de sí mismo y el especificado GraphicsPath objeto. public static B Union(B setOne, B setTwo) { B union = new B(setOne); foreach (int key in setTwo._pixels.Keys) { foreach (int col in setTwo._pixels[key]) { union.Add(col, key); } } return union; }

public static B Intersect(B setOne, B setTwo) { B intersection = new B(); foreach (int key in setTwo._pixels.Keys) { if (setOne._pixels.ContainsKey(key)) { foreach (int col in setTwo._pixels[key]) { if (setOne._pixels[key].Contains(col)) { intersection.Add(col, key); } } } }

90

CAPITULO Apéndice 2 return intersection; }

public static B Complement(B set) { Rect boundary = set.Boundary; B complement = new B(); for (int row = (int)boundary.Top; row <= boundary.Bottom; row++) { for (int col = (int)boundary.Left; col <= boundary.Right; col++) { if (!set._pixels.ContainsKey(row)) { complement.Add(col, row); } else { if (!set._pixels[row].Contains(col)) { complement.Add(col, row); } } } } return complement; }

public static B Translate(B set, int translateX, int translateY) { B translatedSet = new B(); foreach (int y in set._pixels.Keys) { foreach (int x in set._pixels[y]) { translatedSet.Add(x + translateX, y + translateY); } } return translatedSet; }

public static B Dilate(B set, B structuringElement) { B dilatedSet = new B(); foreach (int translateY in structuringElement._pixels.Keys)

91


{ foreach (int translateX in structuringElement._pixels[translateY]) { B translatedSet = new B(); foreach (int y in set._pixels.Keys) { foreach (int x in set._pixels[y]) { translatedSet.Add(x + translateX, y + translateY); } } dilatedSet.Union(translatedSet); } } return dilatedSet; }

{ B erodedSet = new B(set); foreach (int translateY in structuringElement._pixels.Keys) { foreach (int translateX in structuringElement._pixels[translateY]) { B translatedSet = new B(); foreach (int y in set._pixels.Keys) { foreach (int x in set._pixels[y]) { translatedSet.Add(x - translateX, y - translateY); } } erodedSet.Intersect(translatedSet); } } return erodedSet; }

Se hace la aplicacion de erosión public static B Erode(B set, B structuringElement) public WriteableBitmap ToBitmap() { Rect boundary = Boundary;

92

CAPITULO Apéndice 2 WriteableBitmap bmp = new WriteableBitmap((int)boundary.Width, (int)boundary.Height); for (int row = (int)boundary.Top; row < boundary.Bottom; row++) { for (int col = (int)boundary.Left; col < boundary.Right; col++) { unchecked { bmp.Pixels[col - (int)boundary.Left + (row - (int)boundary.Top) * bmp.PixelWidth] = (int)0xFFFFFFFF; } if (_pixels.ContainsKey(row)) { if (_pixels[row].Contains(col)) { unchecked { bmp.Pixels[col - (int)boundary.Left + (row (int)boundary.Top) * bmp.PixelWidth] = (int)0xFF000000; } } } } } return bmp; } }

Archivo MAIN Requerimiento de XML

Contenido de la página

93


Nombre de la aplicación y titulo de la pagina

Contenido adicional, botones y etiquetas

Laura Lopez MSc Thesis

Recommend Documents