seguimiento de un objeto en movimiento mediante captura de
TRANSCRIPT
UNIVERSIDAD TECNOLÓGICA EQUINOCCIAL
FACULTAD DE CIENCIAS DE LA INGENIERÍA E INDUSTRIAS
CARRERA DE INGENIERÍA INFORMÁTICA Y
CIENCIAS DE LA COMPUTACIÓN
SEGUIMIENTO DE UN OBJETO EN MOVIMIENTO MEDIANTE CAPTURA DE VIDEO SOBRE LA PLATAFORMA ANDROID UTILIZANDO LAS
HERRAMIENTAS OPENCV Y WEKA.
TRABAJO PREVIO A LA OBTENCIÓN DEL TÍTULO DE INGENIERO EN INFORMÁTICA Y CIENCIAS DE LA COMPUTACIÓN
GABRIEL DAMIÁN OSORIO PAREDES
DIRECTOR: DR. DIEGO ORDÓÑEZ
Quito, Junio 2016
© Universidad Tecnológica Equinoccial. 2016
Reservados todos los derechos de reproducción
utilizó la librería de código abierto de OpenCv
y para el aprendizaje automático la
herramienta Weka.
El trabajo de titulación está compuesto por
dos aplicaciones. Una aplicación de escritorio
desarrollada en Java con el IDE NetBeans
que permitió categorizar las imágenes
utilizando la librería OpenCv. En esta
aplicación se creó un archivo el cual contiene
las posiciones en X e Y de un punto luminoso.
Este archivo será procesado por la
herramienta Weka para determinar que
algoritmos de aprendizaje automático se
ajustan a las necesidades del proyecto.
La aplicación principal es la que se desarrolló
para Android, esta aplicación capta video y lo
procesa en vivo mediante el uso de la librería
OpenCv para sistemas operativos Android, y
de esta manera determina si existe o no un
punto luminoso o un objeto simple. En caso
de existir un objeto o punto luminoso el
programa envía comandos vía Bluetooth a un
robot para desplazarse manteniendo dicho
objeto en el centro de la pantalla.
El uso de estas herramientas en conjunto
facilitó el procesamiento y la creación del
modelo para cumplir con el objetivo de este
trabajo de titulación. En este documento se
redactan las partes claves del trabajo como
son el tamaño de las imágenes, el banco de
imágenes necesario para crear el modelo, las
librerías de procesamiento de imágenes y los
algoritmos de aprendizaje automático.
PALABRAS CLAVES: Weka, Android, Opencv, Procesamiento De
Imágenes, Aprendizaje Automático
ABSTRACT:
This work aims to identify a blip on a surface,
or a simple object, using the camera of an
Android device. To meet the objective,
libraries for image processing and machine
learning tools were used.
The project was developed with free software
tools such as the NetBeans IDE and Eclipse
in the Java programming language. For image
processing, the open source library OpenCV
and the Weka machine learning tool code
were used.
This project consists of two applications. A
desktop application developed in Java with
NetBeans IDE that allowed to categorize
images using the OpenCV library. In this
application a file containing examples of
positions in X and Y of a blip was created. This
file was processed by the Weka tool to
determine which machine learning algorithms
meet the goals of the project.
The main application is the one developed for
Android, this application captures and
processes live video using the OpenCV library
for Android operating systems, and thus
determines whether there is a blip or a simple
object. If there is an object or blip the program
sends commands via Bluetooth to a robot to
keep the object in the center of the screen.
Using these tools together facilitated the
processing and creation of the model to meet
the objective of this work degree. In this
document the key parts of the job such as the
size of the images, the image bank needed to
create the model, libraries of image
processing and machine learning algorithms
are written.
KEYWORDS
Weka, Android, OpenCv, Image Processing,
Machine Learning
ÍNDICE DE CONTENIDOS PÁGINA
RESUMEN ..................................................................................................... iv ABSTRACT ..................................................................................................... v 1. INTRODUCCIÓN ....................................................................................... 1 2. MARCO TEÓRICO .................................................................................... 5
2.1. PLATAFORMAS MÓVILES. ............................................................. 5 2.1.1. PLATAFORMA ANDROID. ............................................................ 5 2.1.2. PLATAFORMA iOS. ...................................................................... 6 2.1.3. PLATAFORMA WINDOWS PHONE. ............................................ 7
2.2. PLATAFORMA ANDROID VS. PLATAFORMA iOS. ........................ 8 2.3. PROCESAMIENTO DE IMÁGENES. ................................................ 9
2.3.1. IMÁGENES DIGITALES. ............................................................... 9 2.4. VISIÓN POR COMPUTADOR. ....................................................... 10 2.5 OPENCV ......................................................................................... 11
2.5.1. RECONOCIMIENTO DE OBJETOS. ........................................... 11 2.5.2. SEGUIMIENTO DE OBJETOS. ................................................... 12 2.5.3. ESCALA DE GRISES ................................................................. 12 2.5.4. BINARIZACION .......................................................................... 13 2.5.5. FILTROS LINEALES EN IMAGEN DIGITAL ............................... 13 2.5.6 DILATACION Y EROSION ........................................................... 14 2.5.7 ALGORITMO DE SUZUKI ............................................................ 15
2.6. INTELIGENCIA ARTIFICIAL. .......................................................... 15 2.6.1 APRENDIZAJE AUTOMÁTICO. ................................................... 16 2.6.2 MÉTODOS DE APRENDIZAJE AUTOMÁTICO ........................... 17 2.6.3 MINERÍA DE DATOS ................................................................... 19
2.7. APRENDIZAJE AUTOMÁTICO Y VISIÓN POR COMPUTADOR. . 19 2.8 WEKA. ................................................................................................ 20 2.9 METODOLOGÍAS PARA EL DESARROLLO DE SOFTWARE. ......... 21
2.9.1. METODOLOGÍAS TRADICIONALES. ......................................... 21 2.9.2. METODOLOGÍAS ÁGILES. ........................................................ 22 2.9.3. EXTREME PROGRAMMING (XP). ............................................. 23
i
2.9.4. SCRUM. ...................................................................................... 23 3. METODOLOGIA ...................................................................................... 24
3.1 FASE 1: CAPTURA DE IMÁGENES. ................................................. 24 3.2 FASE 2: CATEGORIZACIÓN DE IMÁGENES. .................................. 25 3.3 FASE 3: MODELAMIENTO DE LOS DATOS. .................................... 25 3.4 FASE 4: DESARROLLO DE APLICACIÓN. ....................................... 25
4. ANÁLISIS DE RESULTADOS .................................................................. 27 4.1 CAPTURA DE IMÁGENES. ................................................................ 27 4.2 CATEGORIZACIÓN DE IMÁGENES. ................................................. 28 4.3 CREACIÓN DEL MODELO. ............................................................... 30 4.4 DESARROLLO APLICACIÓN ANDROID. .......................................... 33 4.5 FALSOS POSITIVOS. ........................................................................ 37
5. CONCLUSIONES Y RECOMENDACIONES. .......................................... 39 5.1 CONCLUSIONES ............................................................................... 39 5.2 RECOMENDACIONES ....................................................................... 39
BIBLIOGRAFÍA ............................................................................................ 41
ii
ÍNDICE DE FIGURAS Página
Figura 1. Cuadrícula para la captura de imágenes. ..................................... 24 Figura 2. Cuadricula para la categorización. ................................................ 27 Figura 3. Código botón cargar ...................................................................... 28 Figura 4. Código procesamiento de imagen para la categorización. ............ 28 Figura 5. Creación del archivo csv. .............................................................. 29 Figura 6. Método getPosicion. ...................................................................... 29 Figura 7. Archivo con las Categorías. .......................................................... 30 Figura 8. Interfaz Weka ................................................................................ 30 Figura 9. Selección de Archivo “csv” ............................................................ 31 Figura 10. Filtro no supervisado para cambiar el tipo de clase. ................... 31 Figura 11. Cambio de clase ......................................................................... 32 Figura 12. Resultado árbol de decisión. ....................................................... 32 Figura 13. Árbol de decisión......................................................................... 33 Figura 14. Menú de la Aplicación. ................................................................ 33 Figura 15. Código Menú Laser ..................................................................... 34 Figura 16. Resultado MinMaxLocResult en diferentes superficies. .............. 34 Figura 17. Código del menú Binarizar .......................................................... 35 Figura 18. Resultado por findContours en diferentes superficies. ................ 35 Figura 19. Código menú Otros ..................................................................... 36 Figura 20. Objeto marcados por color .......................................................... 36 Figura 21. Declaración de variables para direccionamiento del robot. ......... 37 Figura 22. Código árbol de decisiones ......................................................... 37 Figura 23. Detección de falsos positivos por MinMaxLocResult de Opencv 38 Figura 24. Detección de falsos positivos por findContours de Opencv ........ 38
iii
RESUMEN
El presente trabajo de titulación tiene como finalidad identificar un punto
luminoso en una superficie, o un objeto simple, a través del sensor de la
cámara de un dispositivo Android. Para cumplir con el objetivo se utilizaron
librerías para el procesamiento de imágenes y herramientas de aprendizaje
automático.
El proyecto se desarrolló con herramientas de software libre como lo son los
IDE NetBeans y Eclipse en el lenguaje de programación Java. Para el
procesamiento de imágenes se utilizó la librería de código abierto de OpenCv
y para el aprendizaje automático la herramienta Weka.
El trabajo de titulación está compuesto por dos aplicaciones. Una aplicación
de escritorio desarrollada en Java con el IDE NetBeans que permitió
categorizar las imágenes utilizando la librería OpenCv. En esta aplicación se
creó un archivo el cual contiene las posiciones en X e Y de un punto luminoso.
Este archivo será procesado por la herramienta Weka para determinar que
algoritmos de aprendizaje automático se ajustan a las necesidades del
proyecto.
La aplicación principal es la que se desarrolló para Android, esta aplicación
capta video y lo procesa en vivo mediante el uso de la librería OpenCv para
sistemas operativos Android, y de esta manera determina si existe o no un
punto luminoso o un objeto simple. En caso de existir un objeto o punto
luminoso el programa envía comandos vía Bluetooth a un robot para
desplazarse manteniendo dicho objeto en el centro de la pantalla.
El uso de estas herramientas en conjunto facilitó el procesamiento y la
creación del modelo para cumplir con el objetivo de este trabajo de titulación.
En este documento se redactan las partes claves del trabajo como son el
tamaño de las imágenes, el banco de imágenes necesario para crear el
modelo, las librerías de procesamiento de imágenes y los algoritmos de
aprendizaje automático.
iv
ABSTRACT
This work aims to identify a blip on a surface, or a simple object, using the
camera of an Android device. To meet the objective, libraries for image
processing and machine learning tools were used.
The project was developed with free software tools such as the NetBeans IDE
and Eclipse in the Java programming language. For image processing, the
open source library OpenCV and the Weka machine learning tool code were
used.
This project consists of two applications. A desktop application developed in
Java with NetBeans IDE that allowed to categorize images using the OpenCV
library. In this application a file containing examples of positions in X and Y of
a blip was created. This file was processed by the Weka tool to determine
which machine learning algorithms meet the goals of the project.
The main application is the one developed for Android, this application
captures and processes live video using the OpenCV library for Android
operating systems, and thus determines whether there is a blip or a simple
object. If there is an object or blip the program sends commands via Bluetooth
to a robot to keep the object in the center of the screen.
Using these tools together facilitated the processing and creation of the model
to meet the objective of this work degree. In this document the key parts of the
job such as the size of the images, the image bank needed to create the model,
libraries of image processing and machine learning algorithms are written.
v
INTRODUCCIÓN
1. INTRODUCCIÓN
Android es un sistema operativo basado en Linux diseñado para teléfonos
móviles y tablets con pantallas táctiles. Su popularidad ha ido en aumento
desde su salida hasta ser uno de los sistemas operativos más utilizados en la
actualidad.
La visión por computador es un campo de rápido crecimiento dedicado a
analizar, modificar y comprender a un alto nivel las imágenes. Su objetivo es
determinar lo que está sucediendo delante de una cámara y utilizar ese
conocimiento para controlar un ordenador o un sistema robótico (Pulli,
Baksheev, Kornyakov, & Eruhimov, 2012).
Las áreas de aplicación de la tecnología de visión por ordenador incluyen
diferentes campos como por ejemplo video vigilancia, biometría, fotografía,
medicina, juegos de realidad aumentada, las nuevas interfaces de usuario, y
muchos más.
Actualmente la mayoría de teléfonos móviles con el sistema operativo Android
poseen incorporada una cámara. Mediante el uso de la cámara del dispositivo
móvil se identificará el ambiente que rodea al robot, se utilizará una biblioteca
especializada para el tratamiento de imágenes llamada OpenCV.
OpenCV (Open Source Computer Vision) es una biblioteca con licencia BSD
de código abierto que incluye varios cientos de algoritmos de visión por
ordenador. («Introduction — OpenCV 2.4.8.0 documentation», 2014)
La biblioteca OpenCV tiene más de 500 funciones realizadas y sus
actualizaciones se lanzan cada 2 años, gracias a su sofisticación permite
desarrollar sistemas significativos con aplicación comercial.(Zelinsky, 2009).
La automatización de dispositivos electrónicos avanza cada día y esto es
posible gracias a la inteligencia artificial y las técnicas para el aprendizaje
automático.
1
La inteligencia artificial forma parte de la informática y su objetivo es imitar la
inteligencia de los seres vivos mediante la estructuración de procesos. Uno de
los campos que más se destaca de la inteligencia artificial es el aprendizaje
automático, “cuyo objetivo es desarrollar técnicas que permitan a las
computadoras aprender; de forma más concreta, se trata de crear programas
capaces de generalizar comportamientos a partir de una información no
estructurada suministrada en forma de ejemplos.” (de la Caridad Rivero-
Hernández, Salgueiro-Sicilia, & Domínguez-López, 2012).
Los algoritmos para aprendizaje automático y el análisis de los datos se los
encuentra en el software libre llamado Weka.
Mediante los algoritmos de la biblioteca OpenCV y los algoritmos de
aprendizaje automático, implementados en la aplicación Android que dirigirá
al robot, se analizará el video captado por la cámara del dispositivo en tiempo
real y se indicará al robot la dirección que debería tomar para mantener el
objeto o punto luminoso centrado en la pantalla del dispositivo móvil.
La tecnología tiene un propósito general, facilitar la vida de las personas. La
automatización de dispositivos tiene un gran campo de aplicación, ya sea en
el hogar, en el sector industrial, inclusive en el ámbito militar.
En la automatización de robots móviles la detección de líneas o carriles ha
ganado una gran atención así como también lo ha hecho en los sistemas de
navegación inteligentes. Algunos de ellos son desarrollados para la plataforma
Android en conjunto con la librería OpenCV (Wei & Meng, 2013).
Mediante el uso de bibliotecas especializadas para el tratamiento de imágenes
se pretende desarrollar una aplicación para el sistema operativo Android que
permita automatizar el movimiento de un robot móvil mediante el análisis de
las imágenes captadas por la cámara del dispositivo.
Este análisis consiste en identificar un punto luminoso sobre una superficie y
ejecutar las instrucciones adecuadas para que el robot se dirija a esa posición.
Actualmente no existe una aplicación orientada a dispositivos móviles que
analice en tiempo real las imágenes con la librería OpenCV y con algoritmos
2
de aprendizaje automático para que detecte un objeto simple o un punto
luminoso y permita guiar el movimiento de un robot.
La detección de objetos es una tecnología de computación relacionada con la
visión artificial y el procesamiento de imágenes que se ocupa de detectar
objetos de una cierta clase de imágenes y videos digitales. (Savitha,
Venugopal, Sarojadevi, & Chiplunkar, 2014).
Esta tecnología se la aplica a diferentes campos, por ejemplo realidad
aumentada, control de tráfico, estudios de imágenes médicas y en la
interacción del hombre con la máquina.
Con la tecnología presente en los dispositivos móviles actuales y su capacidad
de hardware y software estos permiten ejecutar programas avanzados
similares a los que se pueden ejecutar en una computadora. Un dispositivo
móvil en la actualidad puede ser utilizado para el tratamiento de imágenes
gracias a los avances que se han hecho en la biblioteca OpenCV.
Utilizando las herramientas disponibles junto con algoritmos de procesamiento
de imágenes y machine learning se podrá automatizar el movimiento de un
robot. Este robot puede ser utilizado en diferentes ámbitos ya sea industrial o
para asistir a personas con discapacidades visuales u otro tipo de
discapacidades.
Los objetivos que se plantearon fueron:
Diseñar e implementar una aplicación Android-OpenCV-Weka que permita
analizar en tiempo real un flujo continuo de imágenes para detectar un objeto
simple o punto luminoso moviéndose en el piso, e indicar la dirección a seguir
para mantener siempre el punto o el objeto en el centro de la imagen.
Desarrollar un módulo de reconocimiento utilizando los algoritmos contenidos
en la biblioteca OpenCV que permita detectar un punto luminoso en una
captura de video.
Desarrollar un módulo para encontrar la ubicación del objeto a seguir
utilizando la herramienta de aprendizaje automático Weka.
3
Desarrollar un módulo de direccionamiento basado en un modelo de
aprendizaje automático para guiar al robot mediante comandos bluetooth.
4
MARCO TEÓRICO
2. MARCO TEÓRICO
2.1. PLATAFORMAS MÓVILES.
Ya hay más teléfonos móviles que ordenadores conectados a Internet.
Mientras que una minoría de esos teléfonos se consideraría Smartphone, se
está viendo un movimiento rápido donde los teléfonos de gama alta de hoy en
día se convierten en el año siguiente en dispositivos de gama media o incluso
en dispositivos de gama baja. (Allen, Graupera, & Lundrigan, 2010)
El diseño de plataformas móviles se ha apoyado gradualmente en el uso de
sensores integrados para optimizar la operación de la plataforma (por ejemplo,
la brújula digital, sensores de proximidad y sensores acelerómetros), y para
ofrecer servicios de alto nivel a los usuarios (por ejemplo, cámaras digitales y
sensores NFC).Como consecuencia de las innovaciones de hardware y
refinamientos, nuevas arquitecturas de software y sistemas operativos han
sido creados desde cero. Como resultado se obtuvieron tres poderosas
plataformas nativas: Android de Google, Apple iOS y Windows Phone de
Microsoft. (Helal, Bose, & Li, 2012)
2.1.1. PLATAFORMA ANDROID.
En 2005, Google compró una compañía pequeña fundada por Andy Ruben.
El 5 de noviembre de 2007, Google anunció el sistema operativo Android y la
Open Handset Alliance, un grupo de empresas que ayuden a desarrollarlo.
Los miembros de Open Handset Alliance incluyen compañías de teléfonos,
desarrolladores de software, fabricantes de dispositivos y fabricantes de
componentes.
Android tiene una filosofía muy diferente en comparación con Apple y el
iPhone. Cualquiera podría utilizar Android en sus dispositivos de forma
5
gratuita, cualquier persona podría modificar Android, y cualquier persona
puede desarrollar aplicaciones para ella sin pedir permiso para colocar sus
aplicaciones en el Android Market. (Karch, 2010)
Se diversifica con lectores de libros electrónicos, tabletas, e incluso
dispositivos médicos. El costo y su fácil personalización se prestan a todo tipo
de aplicaciones para dispositivos portátiles. Android está disponible como una
plataforma móvil de código abierto bajo la Licencia Pública General de GNU y
la licencia Apache 2.0.
Esto permite que cualquiera que esté interesado, para descargar y
personalizar su código fuente o para su propio uso sin pagar derechos de
licencia o regalías al consorcio. Cada actualización importante de la
plataforma Android se identifica por el nombre de un postre. (Helal et al., 2012)
El editor más utilizado y recomendado es el de Eclipse con el plug-in Android
Development Tools. El plug-in proporciona un entorno de desarrollo completo
que se integra con el emulador. Proporciona capacidades de depuración y
permite instalar fácilmente varias versiones de la plataforma Android. (Allen
et al., 2010)
2.1.2. PLATAFORMA iOS.
iOS es el sistema operativo de Apple Inc. que alimenta todos sus dispositivos
móviles, que van de los reproductores multimedia iPod touch a la tableta iPad
(http://www.apple.com/ios). Fue diseñado desde cero como un sistema
operativo para dispositivos con pantalla táctil y está basado en el kernel XNU
de Mac OS X. iOs fue lanzado originalmente en 2007 como el sistema
operativo para iPhone.
Fue el primer sistema operativo móvil comercial en proporcionar una interfaz
de usuario con capacidad multi-touch y comenzó la tendencia de la industria
de dispositivos con pantallas táctiles. (Helal et al., 2012)
6
Para desarrollar aplicaciones para el iPhone o iPod touch, se necesita un
equipo Macintosh basado en Intel con OS X v10.5.7 o posterior. Xcode es el
entorno de desarrollo integrado de Apple para el desarrollo de aplicaciones
para Mac OS X y dispositivos iOs.
El lenguaje preferido en Xcode es Objective-C, que es necesario para las
aplicaciones del iPhone, pero Xcode también es compatible con una gran
variedad de otros lenguajes (C, C + +, Fortran, Java, Objective-C + +,
AppleScript, Python y Ruby). El IDE de Xcode tiene un compilador GNU
modificado y depurador para su backend. (Allen et al., 2010)
2.1.3. PLATAFORMA WINDOWS PHONE.
Windows Phone 8.1 es el último sistema operativo para teléfonos móviles de
Microsoft. Anteriormente, Microsoft creó el software llamado "Windows
Mobile", que se desarrolló en los teléfonos inteligentes y se veía muy similar
a la forma en que aparece en Windows en las computadoras de escritorio.
(Westfall, 2011)
Aproximadamente el 15% de los teléfonos inteligentes actualmente funcionan
en la plataforma Windows Phone y sigue siendo la tercera plataforma más
popular para los usuarios de negocios, al mando de aproximadamente 1/4 del
mercado empresarial. (Allen et al., 2010)
Su plataforma de desarrollo se llama Windows Phone Developer Tools. Las
herramientas incluyen Visual Studio 2010 Express para Windows Phone, XNA
Game Studio 4 y Expression Blend 4 para Windows Phone, todo lo que se
necesita en una sola descarga gratuita. (Cameron, 2011)
7
2.2. PLATAFORMA ANDROID VS. PLATAFORMA iOS.
La comparación entre estos dos sistemas operativos fue tomada de (Shih,
Lakhani, & Nagy, 2010)
Una ventaja clave de la forma de Apple y el iPhone es su ambiente muy
estrechamente controlado, es más fácil de desarrollar, probar y mantener
aplicaciones debido a que el tamaño de la pantalla, hardware, etc, están
estandarizados. El desarrollo en Android será mucho más difícil, ya que un
desarrollador se tiene que dar cuenta de todos los demás requisitos y/o
limitaciones de los diferentes fabricantes de hardware.
Apple requiere una suscripción por 99 dólares, como parte del Programa de
Desarrolladores de Apple, y obtener un ID de Apple para obtener el kit de
desarrollo de software de iPhone. En comparación. El iPhone SDK se puede
descargar gratis, utiliza 5 gigas de disco duro para instalar y requiere Leopard
10.5.5 o superior para instalar el paquete entero. XCode 3, el IDE de Apple,
ha sido descrito como el entorno de desarrollo mejor integrado para
dispositivos móviles.
Android se basa en el sistema operativo Linux y utiliza el lenguaje de
programación Java, así que debería ser relativamente fácil trasladar las
aplicaciones de PC existentes para Android. Desarrolladores entrenados en
Java puede desarrollar fácilmente aplicaciones para esta plataforma.
Google y Apple tienen radicalmente diferentes modelos empresariales y
filosofías. Mientras que Google promueve la libertad y flexibilidad con el
Android, Apple controla prácticamente todo lo relacionado con el iPhone. Por
un lado, el sistema operativo del iPhone es de código cerrado, en segundo
lugar, para unirse a su programa para desarrolladores, primero se tiene que
pagar una cuota anual.
Android es presentado en varios teléfonos inteligentes, cada uno con
diferentes características y potencial, y será fácilmente maleable, ya que es
8
de código abierto. Este potencial para la diversidad es atractiva y facilitará la
adopción y adaptación global.
2.3. PROCESAMIENTO DE IMÁGENES.
El procesamiento de imágenes se utiliza en una amplia variedad de
aplicaciones, para dos propósitos algo diferentes:
1. Mejorar la apariencia visual de las imágenes para un observador humano,
incluyendo la impresión y la transmisión.
2. Preparación de imágenes para la medición de las características y
estructuras que revelan.
Las técnicas que son apropiadas para cada una de estas tareas no siempre
son las mismas, pero hay una considerable superposición.
La medición de imágenes es a menudo un método principal para la adquisición
de datos científicos y generalmente requiere que las características o
estructuras estén bien definidas, ya sea por bordes o brillo único, color,
textura, o alguna combinación de estos factores. Los tipos de mediciones que
se pueden realizar en escenas enteras o en las características individuales
son importantes en la determinación de las etapas de procesamiento. Los
datos de medición pueden ser utilizados para la clasificación o reconocimiento
de objetos. (Russ, 2011)
2.3.1. IMÁGENES DIGITALES.
Las imágenes se representan por matrices de dos dimensiones en los
ordenadores. El mundo es tridimensional, pero nuestras cámaras tienen una
matriz bidimensional de sensores de luz, lo que crea una matriz bidimensional
correspondiente de valores de intensidad de luz. Cada elemento de la imagen
se llama pixel. La memoria de la computadora se organiza en torno a
conjuntos de bytes.
9
Los valores de los píxeles que representan los niveles de luz pueden ser un
valor cero que significa la falta de luz, es decir, oscuro, mientras que 255
representa el valor máximo posible de luz, que es blanco. Cuando se habla
de colores, por ejemplo, rojo, el significado es el mismo: 0 significa que no hay
rojo, y 255 se refiere a la intensidad máxima de color rojo perceptible. (Abreu,
2013)
2.4. VISIÓN POR COMPUTADOR.
La visión por computador es la ciencia de programar un ordenador para
procesar y finalmente comprender las imágenes y video, o simplemente decir
que un ordenador vea. (Laganiere, 2011)
Las siguientes aplicaciones de la visión por computador fueron tomadas de
(Dawson-Howe, 2014). La visión por computador permite la inspección
automática de los productos manufacturados en cualquier etapa en la línea
de producción. Por ejemplo, se ha utilizado para:
• Inspección en circuitos impresos para asegurar que las pistas y los
componentes están correctamente colocados.
• Inspección en la calidad de impresión de las etiquetas.
• Inspección en botellas para garantizar que estén debidamente llenas.
• Inspección en las manzanas para determinar si hay alguna
magulladura.
La visión por computador también está resolviendo los problemas fuera de la
fábrica. Aplicaciones de visión por ordenador fuera de la fábrica incluyen:
• Lectura automática de matrículas de vehículos a medida que pasan a
través de las barreras de peaje en las carreteras principales.
• Controles de seguridad biométricos en los aeropuertos que utilizan
imágenes de rostros y las imágenes de las huellas dactilares.
• Asistir al conductor, advirtiendo cuando están fuera del carril.
• Detección de minas terrestres enterradas en imágenes infrarrojas.
10
2.5 OPENCV
OpenCV (Open source computer vision) es una biblioteca de visión por
computador de código abierto, con más de 500 algoritmos optimizados para
el análisis de imagen y vídeo. OpenCV fue diseñado para la eficiencia
computacional y con un fuerte enfoque en las aplicaciones en tiempo real.
(Datal & Patel, 2013)
Uno de los objetivos de OpenCV es proporcionar una infraestructura fácil de
utilizar y ayudar a las personas a construir aplicaciones de visión por
computador bastante sofisticadas rápidamente.
La licencia de código abierto para OpenCV se ha estructurado de tal manera
que se puede construir un producto comercial utilizando la totalidad o parte de
OpenCV. OpenCV es popular en todo el mundo, con grandes comunidades
de usuarios en China, Japón, Rusia, Europa e Israel. OpenCV fue una parte
clave del sistema de visión en el robot de Stanford, "Stanley", que ganó la
carrera DARPA Grand Challenge con un premio de $2,000,000.
(Bradsky&Kaehler, 2008)
2.5.1. RECONOCIMIENTO DE OBJETOS.
La detección de objetos y el reconocimiento de objetos están estrechamente
vinculados, en cierta medida ambos dominios se pueden ver como la
clasificación de patrones y frecuentemente la detección de objetos precede al
reconocimiento.
El objetivo del reconocimiento de objetos es identificar su tipo particular. La
detección y reconocimiento de objetos en las escenas observadas es una
capacidad biológica natural. Las personas y los animales realizan esto sin
esfuerzo en la vida cotidiana. Sin embargo, los métodos informáticos similares
y algoritmos para el análisis de escenas no son tan sencillos, a pesar de su
desarrollo sin precedentes. (Cyganek, 2013)
11
2.5.2. SEGUIMIENTO DE OBJETOS.
Una parte importante de la visión por computador es el seguimiento de
objetos, ésta ha crecido y llamado la atención por décadas. El seguimiento de
objetos tiene un gran campo de aplicación como lo es interacción hombre-
máquina, video vigilancia y sistemas guiados de conducción. Generalmente
un algoritmo de rastreo puede categorizarse como un método generativo o un
método discriminativo.
Un problema para el seguimiento de objetos es escoger las características
claves. El éxito o el fracaso depende en primer lugar de cuanto se puede
distinguir el objeto de los objetos que lo rodean, que tiene que ver con las
características claves escogidas. Hay muchas características que pueden ser
escogidas para el seguimiento de objetos como lo son:
• Color
• Textura
• Patrones locales binarios
• Características de codificación dispersa, etc. (D. Wang, Lu, Xiao, &
Chen, 2013)
El seguimiento de objetos en tiempo real ha crecido rápidamente debido al
poder de procesamiento de las máquinas actuales y la existencia de cámaras
compactas baratas. La mayoría de las aplicaciones de seguimiento utiliza el
seguimiento basado en características. En este caso la detección de punto de
interés y descriptores de características son el primer paso. (Gauglitz,
Höllerer, & Turk, 2011)
2.5.3. ESCALA DE GRISES
Una imagen en escala de grises solo contiene información de la intensidad de
luz no del color, las imágenes a color usualmente tienen 3 canales. Para
obtener una imagen en escala de grises se almacena solo la intensidad de
cada canal y se descarta la información del color.
12
El formato más común para imágenes digitales es RGB; Red=rojo,
Green=verde y B=azul; esto significa que la intensidad de cada color está
almacenada de manera independiente en la imagen, haciendo un promedio
de estos valores se puede obtener una imagen en escala de grises.
(Montabone, 2010)
El valor de los pixeles de una imagen en escala de grises está entre 0 y 255.
Siendo 0 la mínima intensidad y 255 la máxima. (Fisher et al., 2013)
2.5.4. BINARIZACIÓN
Las imágenes en escala de grises generalmente tienen 8 bits por pixel.
Procesar imágenes en escala de grises es más sencillo que procesar
imágenes a color, hay otra forma de imagen, la imagen binaria. Una imagen
binaria es la que tiene un solo bit por pixel, es decir blanco o negro. (Dawson-
Howe, 2014)
La binarización de imágenes ha sido aplicada ampliamente como una forma
básica en la etapa de pre-procesamiento en muchas tareas de análisis de
imagen. (Ranchordas, Pereira, Araujo, & Tavares, 2010)
Procesar imágenes binarias tiene una menor carga computacional que
procesar imágenes en escala de grises.
2.5.5. FILTROS LINEALES EN IMAGEN DIGITAL
Los filtros lineales se usan en Procesamiento Digital de Imágenes para
obtener alguna modificación específica de la imagen que permita facilitar su
tratamiento. Se caracterizan especialmente por implementar una respuesta
impulsiva h(x,y), o también llamado Kernel. Los usos de los filtros son
diversos, entre ellos se encuentran los filtros Suavizadores, Realzadores de
Contornos, de Gradiente y Direccionales. En este apartado solo se revisarán
los dos primeros mencionados.
13
2.5.5.1 Filtros suavizadores Este tipo de filtros calculan un promedio alrededor de un pixel. En la práctica,
son filtros Paso-bajo y tienen como objetivo reducir la diferencia de valores
entre un pixel y sus pixeles vecinos mediante el uso de un kernel Rectangular
o de aproximación Gaussiana. La aplicación de estos filtros producen
degradación de la imagen (le da un efecto desenfocado) debido a la
difuminación de las líneas de contorno. (Pertusa Grau, 2011)
2.5.5.2 Suavizadores gaussianos
Estos son filtros suavizadores que utilizan un kernel Gaussiano. En este tipo
de filtrado se le da más importancia al pixel central y sus vecinos cercanos, y
menos peso a los pixeles lejanos. El kernel tiene una forma de campana,
asemejándose mucho a una función de Gauss.
Esto ocasiona un suavizado mucho menos abrupto que otros tipos de filtro, ya
que los valores de los pixeles decaen continuamente y no realizan un cambio
brusco de valor con sus vecinos. (Albiol, 2013)
2.5.6 DILATACION Y EROSION
La dilatación y la erosión son dos de las operaciones morfológicas más
fundamentales. Estas dos operaciones trabajan con los vecinos de un pixel.
La erosión reemplaza el pixel actual con el valor mínimo del conjunto de
pixeles definidos. La dilatación es el operador complementario y reemplaza el
valor del pixel actual con el valor máximo del conjunto de pixeles definidos.
Estos operadores trabajan con imágenes binarias, y debido a que estas
imágenes solo contienen valores de 0 o 1, o blanco y negro, cada pixel es
reemplazado por un pixel blanco o negro. (Laganiere, 2011)
14
2.5.7 ALGORITMO DE SUZUKI
Este método propone dos algoritmos de análisis topológico para las imágenes
binarizadas. El primero de ellos determina la relación que existe entre los
bordes y la imagen binaria en sí, de tal forma que revisa las conexiones 1-a-1
de los píxeles y determina como están relacionados los bordes internos y
externos de un objeto; a partir de eso se pueden obtener una serie de
características del mismo sin necesidad de reconstruir la imagen.
El segundo algoritmo es una modificación del primero, y solo se analizan los
borden externos del objeto. Este algoritmo es muy útil es sistemas de conteo
o análisis estructural de imágenes binarias. (Suzuki & Abe, 1985)
La función de OpenCV “findContours” devuelve los contornos de una imagen
binaria utilizando el algoritmo de Suzuki anteriormente mencionado. Los
contornos son una herramienta útil para analizar la forma de un objeto
detectarlo y reconocerlo. («Structural Analysis and Shape Descriptors —
OpenCV 2.4.11.0 documentation», 2015).
2.6. INTELIGENCIA ARTIFICIAL.
Inteligencia Artificial (IA) se suele definir como la ciencia y la ingeniería de
imitar, ampliar y aumentar la inteligencia humana a través de los medios y
técnicas para hacer máquinas inteligentes artificiales. Parte de la definición de
la inteligencia es acerca de la capacidad de aprender. Hasta cierto punto, las
computadoras pueden aprender a resolver problemas, dependiendo de los
tipos de problemas que reciben. (Shi, 2011).
Los pequeños problemas que se pueden resolver actualmente con la IA
incluyen el reconocimiento de voz, reconocimiento de objetos visuales, gran
capacidad de almacenamiento y velocidades de computación
extremadamente rápidas. La IA puede hacer frente a algunas áreas muy
limitadas. Los sistemas expertos pueden resolver problemas en áreas muy
específicas, casi al igual que los seres humanos pueden.
15
Los sistemas expertos, por ejemplo, pueden leer monitores cardíacos e
interpretarlos, así como muchos médicos humanos. El software puede traducir
de un idioma a otro bastante bien.
Un proyecto más reciente es el Proyecto de coches sin conductor de Google.
Los coches de Google han conducido hasta 1000 millas (1600 kilómetros) sin
ayuda humana y un total de 140000 millas con muy poca orientación humana.
En todo ese tiempo, el único accidente fue cuando uno de los coches de
Google era dirigido por una persona, un error humano y no un error de la
máquina. Puede ser que la tecnología desarrollada por Google podría ser la
primera de su tipo en ser vendida.(Karam, 2011)
2.6.1 APRENDIZAJE AUTOMÁTICO.
El aprendizaje es la adquisición de nuevos o la modificación de los
conocimientos existentes, comportamientos, habilidades, valores o
preferencias y puede implicar la síntesis de diferentes tipos de información. El
aprendizaje en los animales y los seres humanos ha sido explorado por los
biólogos y psicólogos por igual.
Muchas de las técnicas de aprendizaje automático se derivan de los esfuerzos
de los psicólogos para hacer más precisas sus teorías de los animales y del
aprendizaje humano a través de modelos computacionales. Varias disciplinas
como la inteligencia artificial, sistemas de control adaptativo, modelos
evolutivos basados en biología, estadísticas, modelos psicológicos han
contribuido al aprendizaje automático. (Ramanna, Jain, & Howlett, 2012)
El principio básico del aprendizaje automático es el modelado automático del
proceso que han generado los datos recogidos. Se aprende de los resultados,
de los datos en las reglas, funciones, relaciones, sistemas de ecuaciones, las
distribuciones de probabilidad y otras representaciones del conocimiento,
tales como reglas de decisión, árboles de decisión y regresión, redes
bayesianas, redes neuronales, etc.
16
El análisis de datos manual ya no es suficiente, y los métodos para el análisis
computarizado eficiente ahora son necesarios. Por lo tanto, un nuevo campo
interdisciplinario ha surgido, que abarca estadística, reconocimiento de
patrones, aprendizaje automático y herramientas de visualización para apoyar
el análisis de datos y descubrimiento de principios ocultos dentro de los datos.
En diferentes comunidades de este campo se conoce con diferentes nombres:
descubrimiento de conocimiento en bases de datos (KDD), minería de datos
(DM), o el análisis inteligente de datos (IDA). (Kononenko & Kukar, 2007)
(Lantz, 2013) propone dividir la tarea de aprendizaje automático en una serie
de pasos manejables. Como son:
• Recopilación de datos.
• Exploración y preparación de los datos
• Entrenamiento de un modelo sobre los datos.
• Evaluar el desempeño del modelo.
• Mejorar el rendimiento del modelo.
Después de que estos pasos se han completado, si el modelo parece estar
funcionando de manera satisfactoria, se puede implementar para la tarea
prevista.
2.6.2 MÉTODOS DE APRENDIZAJE AUTOMÁTICO
Los métodos del aprendizaje automático se dividen en:
• Clasificación.- Los métodos de aprendizaje automático se utilizan con
mayor frecuencia para la clasificación. Los métodos de aprendizaje
automático se emplean para la creación de clasificadores. La tarea del
clasificador es determinar la clase a la que se le debe asignar el objeto
en cuestión.
Los clasificadores más comunes son: árboles de decisión, reglas de
decisión, clasificadores bayesianos, redes bayesianas, clasificadores
17
de vecinos más cercanos, funciones discriminantes lineales, regresión
logística y redes neuronales artificiales.
• Regresión.- Al igual que en los problemas de clasificación, en la
regresión se tienen un conjunto de objetos (ejemplos de aprendizaje),
que se describe con varios atributos (características, propiedades). Los
atributos son variables observables independientes (ya sean continuos
o discretos). Los predictores de regresión más comunes son: regresión lineal,
árboles de regresión, regresión ponderada localmente, y redes
neuronales multicapa para la regresión.
• Relaciones lógicas.- Las relaciones lógicas pueden ser considerados
como una generalización de las funciones discretas. A diferencia de las
funciones, no hay una única variable discreta dependiente (clase), y
todas las variables (atributos) se tratan de manera equivalente. Los algoritmos que se pueden encontrar son: las asociaciones y
programación lógica inductiva.
• Clustering.- El aprendizaje no supervisado es diferente del de
clasificación y regresión, sólo se da la descripción de ejemplos con
atributos, y sin la variable de supervisión. Clustering es el más popular
de los métodos de aprendizaje no supervisado. Los algoritmos más
conocidos son: Clustering jerárquico y clustering particional.
• Aprendizaje por refuerzo.- El aprendizaje por refuerzo trata con el
problema de la enseñanza a un agente autónomo que actúa y siente
su entorno y de esta manera elige acciones óptimas para el logro de
sus metas. El aprendizaje por refuerzo es usado frecuentemente para
controlar sistemas dinámicos como los robots, resolver varios
problemas de optimización y en videojuegos. (Kononenko & Kukar,
2007)
18
2.6.3 MINERÍA DE DATOS
La minería de datos se define como el proceso de descubrimiento de patrones
en los datos. El proceso debe ser automático o (más habitualmente)
semiautomático. Los patrones descubiertos deben ser significativos y conducir
a alguna ventaja, por lo general de carácter económico. Los datos son
invariablemente presentes en cantidades sustanciales.
En la minería de datos (data mining), los datos se almacenan
electrónicamente y la búsqueda está automatizada. Incluso esto no es
particularmente nuevo. Los economistas, estadísticos, analistas e ingenieros
de la comunicación han trabajado durante mucho tiempo con la idea de que
los patrones en los datos se pueden buscar de forma automática,
identificarlos, validarlos, y utilizarlos para la predicción.
Los datos analizados adecuadamente son un recurso valioso. Puede conducir
a nuevos conocimientos. (Witten, Frank, & Hall, 2011)
La minería de datos se utiliza rutinariamente para detectar el fraude de tarjetas
de crédito, ayudar a determinar si es probable pagar un préstamo, llevar a
cabo la investigación de mercados, clasificar a través de enormes cantidades
de datos científicos, y así sucesivamente.
El software de minería de datos puede ser increíblemente sofisticado. Es
capaz de detectar los patrones que la mayoría de la gente no podría. Sin
embargo, aun con todo este poder, el software de minería de datos no es
inteligente. (Karam, 2011)
2.7. APRENDIZAJE AUTOMÁTICO Y VISIÓN POR COMPUTADOR.
El aprendizaje es una de las fronteras actuales en la investigación de visión
por computador y ha estado recibiendo cada vez más atención en los últimos
años.
19
La tecnología de aprendizaje automático tiene un gran potencial para
contribuir a:
• El desarrollo de algoritmos de visión flexibles y robustos que mejorarán
el rendimiento de los sistemas de visión con un mayor nivel de
competencia y una mayor generalidad.
• El desarrollo de arquitecturas que acelerarán el tiempo de desarrollo
del sistema y proporcionaran un mejor rendimiento.
Los algoritmos de aprendizaje automático se pueden aplicar en al menos dos
formas diferentes en los sistemas de visión informáticos:
• Para mejorar la percepción del medio ambiente circundante, es decir,
para mejorar la transformación de señales detectadas en
representaciones internas.
• Para cerrar la brecha entre las representaciones internas del medio
ambiente y la representación del conocimiento que necesita el sistema
para llevar a cabo su tarea. (Sebe, Cohen, & Garg, 2006)
2.8 WEKA.
Weka es una colección de algoritmos de aprendizaje automático para tareas
de minería de datos. Los algoritmos bien se pueden aplicar directamente a un
conjunto de datos o llamados desde su propio código Java. Weka contiene
herramientas para el pre-procesamiento de datos, clasificación, regresión,
clustering, reglas de asociación, y la visualización. También es muy adecuado
para el desarrollo de nuevos sistemas de aprendizaje automático. (The
University of Waikato, 2014)
La intuición humana no puede ser reemplazada en su totalidad, ya que el
diseñador del sistema ha de especificar la forma de representación de los
datos y los métodos de manipulación y caracterización de los mismos. (De la
Caridad Rivero-Hernández et al., 2012)
20
2.9 METODOLOGÍAS PARA EL DESARROLLO DE SOFTWARE.
La ingeniería de software es una disciplina que estudia la naturaleza del
software, enfoques y metodologías para el desarrollo de software a gran
escala. (Y. Wang, 2007)
Muchos sistemas de software están pobremente documentados. Los
programadores pasan mucho tiempo en desarrollar funcionalidades en vez de
documentarlas. Esto provoca un problema porque después de algún tiempo
es difícil entender el sistema. La tarea de darle mantenimiento al sistema
puede ser difícil al no existir documentación de las funcionalidades existentes.
(Lo, Khoo, Han, & Liu, 2011)
2.9.1. METODOLOGÍAS TRADICIONALES.
El ciclo de vida del desarrollo de software incluye todos los eventos que
suceden en la producción de un software. Aunque los ciclos de vida han
sufrido muchos cambios y evolucionado a lo largo de un período de tiempo,
se consideran dos enfoques fundamentales: cascada e iterativo incremental.
(Krishnamurthy & Saran, 2007)
• Cascada.
Uno de los modelos de ciclo de vida más conocidos es el modelo de cascada.
Fue descrito por primera vez formalmente por Winston Royce en 1970. La
idea detrás del modelo de cascada es la creación secuencial de productos en
diferentes niveles de abstracción y la integración en la dirección inversa.
Cumplir con el orden secuencial de las actividades es muy difícil de conseguir,
incluso si se permite la interacción con las actividades vecinas inmediatas. Los
requisitos necesarios para la aplicación de un enfoque de creación de
prototipos incluyen estar familiarizados con el dominio, métodos, técnicas,
21
herramientas, procesos de ingeniería y con una muy buena comprensión de
los requisitos. (Münch, Armbrust, & Kowalczyk, 2012)
Iterativo, incremental.
La mayoría de los ciclos de vida de desarrollo de software modernos subrayan
iteración durante todo el proceso y les agregan funcionalidades incrementales
dentro de cada iteración.
Esta es la base para la mayoría de los procesos de desarrollo de software
modernos. En el modelo en espiral, el ciclo comienza con ciertos requisitos.
Proyectos de riesgos, con respecto a los requisitos, se evalúan, y la aplicación
(desarrollo) del producto para esa iteración comienza. Una vez que se haya
completado, se obtiene la retroalimentación de los clientes, y la siguiente
iteración se inicia.
En esta iteración, de nuevo, los artículos más altos de riesgo se tratan primero.
Mientras que las partes de este bucle pueden cambiar, el patrón de la
repetición y la entrega incremental del producto se repiten a lo largo del ciclo
de vida. (Krishnamurthy & Saran, 2007)
2.9.2. METODOLOGÍAS ÁGILES.
El desarrollo ágil de software es un intento de poner el software a desarrollar
primero y reconocer que las necesidades de los usuarios cambian. Es ágil, ya
que puede responder rápidamente a las necesidades cambiantes de los
usuarios. El desarrollo ágil de software consta principalmente en versiones de
software frecuente y regular. Esto permite que las nuevas versiones de
software sean entregadas a los usuarios de forma rápida y con frecuencia.
(Hunt, 2006)
22
2.9.3. EXTREME PROGRAMMING (XP).
XP es una metodología ligera que se centra en la codificación como la tarea
principal. Con XP, las actividades centradas en el código están en todas las
etapas del ciclo de vida de desarrollo de software. Algunos profesionales de
las metodologías más tradicionales han criticado XP, afirmando que se trata
de la codificación imprudente y no es un proceso real.
Por el contrario, XP es una metodología muy disciplinada que se centra en la
revisión de código constante, pruebas frecuentes, participación de los clientes,
retroalimentación rápida y la integración continua para descubrir problemas a
tiempo en el proceso de desarrollo.
El autor principal de esta metodología definió 4 puntos claves:
Comunicación, simplicidad, retroalimentación y coraje. (Hightower et al., 2004)
2.9.4. SCRUM.
Scrum (Schwaber 1995; Schwaber y Beedle 2002) ha sido desarrollado para
la gestión del proceso de desarrollo de software en un entorno volátil. Se basa
en la flexibilidad, la capacidad de adaptación y la productividad. Scrum deja
abierto la posibilidad a los desarrolladores elegir las técnicas específicas de
desarrollo de software, métodos y prácticas para el proceso de
implementación.
Esto involucra manejo frecuente de las actividades y está destinado a
identificar sistemáticamente las deficiencias o impedimentos en el proceso de
desarrollo, así como el de las prácticas que se utilizan. (Dingsoyr, Dyba, &
Moe, 2010)
23
METODOLOGÍA
3. METODOLOGÍA
La aplicación se la diseñó y desarrolló para mantener centrado en la pantalla
de un dispositivo Android un punto luminoso o un objeto de un solo color,
mediante el uso de herramientas open source como lo son OpenCv y Weka.
Para el desarrollo de las aplicaciones se usó la metodología eXtreme
Programming.
A continuación se detallan las fases para la realización del proyecto.
3.1 FASE 1: CAPTURA DE IMÁGENES.
Para la captura de imágenes se utilizó la aplicación “Cámara de Google” la
cual se puede descargar gratis de la “Play Store” ésta aplicación ofrece la
opción de tomar fotos en una resolución de 0.3 megapíxeles además ofrece
una cuadrícula de 3x3 es decir 3 filas de alto por 3 filas de ancho como se
muestra en la Figura 1.
Figura 1. Cuadrícula para la captura de imágenes.
24
3.2 FASE 2: CATEGORIZACIÓN DE IMÁGENES.
Para el procesamiento de las imágenes se desarrolló una aplicación en Java
con el IDE Netbeans en la cual se cargan las imágenes que se obtuvieron de
la fase 1 y se indica la categoría en la que se encuentra el objeto dependiendo
de la posición en la que se encuentra. Para lograr esto se probaron diferentes
técnicas de procesamiento de imágenes y librerías de OpenCv.
Las librerías que se utilizaron son:
- Escala de grises
- Binarización
- Dilatación.
3.3 FASE 3: MODELAMIENTO DE LOS DATOS.
En esta fase se utilizó la herramienta de Machine Learning, Weka. En esta
herramienta se carga un set o conjunto de datos, los cuales fueron obtenidos
en la fase 2, estos datos serán analizados por diferentes algoritmos y
dependiendo del mejor resultado, es decir el que menos error posea, será el
que se ajuste mejor a las necesidades de la aplicación. Entre los algoritmos
probados se encuentran: NaiveBayes, IBk, IB1, LinearRegression, árboles de
decisión, Kstar , M5Rules, M5P entre otros.
3.4 FASE 4: DESARROLLO DE APLICACIÓN.
La aplicación se desarrolló en eclipse con el plugin de Android. Se basó en el
programa BlobDetectors de la librería de OpenCv. En esta fase se probaron
diferentes técnicas para el procesamiento de imágenes de video las cuales
ayuden a detectar el punto luminoso con la menor cantidad de falsos positivos.
25
Entre los algoritmos de procesamiento de imágenes que se utilizaron están:
transformación a escala de grises, binarización, filtros gaussianos, dilatación,
entre otros.
26
ANÁLISIS DE RESULTADOS
4. ANÁLISIS DE RESULTADOS
La finalidad del proyecto es diseñar e implementar una aplicación en Android
que detecte un punto luminoso o un objeto simple y pueda tener dicho objeto
centrado en la pantalla acorde se vaya moviendo el objeto. A continuación se
detallan los pasos para el desarrollo de la aplicación y su ejecución.
4.1 CAPTURA DE IMÁGENES.
Las imágenes fueron tomadas con la aplicación Cámara de Google en una
resolución de 0.3 megapíxeles, es decir 640 píxeles de ancho por 480 píxeles
de alto. Ésta es la resolución mínima que permite la aplicación.
Se tomaron 400 imágenes, 40 imágenes por cada uno de los segmentos. La
aplicación tiene una cuadrícula de 3x3.
Lo que indica que existen 10 categorías, la décima categoría es cuando no
hay un objeto para categorizar. En la Figura 2 se muestran las categorías.
1 2 3
4 5 6
7 8 9
Figura 2. Cuadricula para la categorización.
27
4.2 CATEGORIZACIÓN DE IMÁGENES.
Para la categorización de imágenes se desarrolló un programa en Java con el
IDE NetBeans y la librería OpenCv.
El programa posee un interfaz simple, el botón cargar abre un cuadro de
diálogo que permite seleccionar una imagen para procesarla y determinar la
categoría a la que pertenece. En la Figura 3 se muestra el método para la
carga de imágenes.
Figura 3. Código botón cargar
Para el procesamiento de imágenes se utilizó las librerías de OpenCv. La
imagen cargada se la pasa a un objeto de tipo matriz de OpenCv y se procede
con el procesamiento de la imagen como se muestra en la Figura 4.
Figura 4. Código procesamiento de imagen para la categorización.
28
Una vez procesada la imagen se la muestra en la interfaz de usuario. El
resultado será una imagen binarizada, es decir sus pixeles tendrán valores de
0 o 1.
Para guardar el valor de la categoría correspondiente a la imagen se crea un
archivo separado por comas (.csv) este archivo sirve para crear el modelo que
guiará al robot más adelante. En la Figura 5 se muestra el código para la
creación del archivo.
Figura 5. Creación del archivo csv.
El método getPosicion devuelve como una cadena de texto la posición del
pixel más luminoso en el eje X e Y de la imagen cargada. En la Figura 6 se
muestra el código.
Figura 6. Método getPosicion.
29
El archivo que se obtiene después de procesar y clasificar las 400 imágenes
es un archivo plano y puede ser visualizado por cualquier procesador de
texto. Este archivo está compuesto por un encabezado y sus valores. En la
Figura 7 se puede observar la categorización.
Figura 7. Archivo con las Categorías.
4.3 CREACIÓN DEL MODELO.
Para crear el modelo se utilizó la herramienta Weka y el archivo “csv” que se
obtuvo del programa en NetBeans con las 400 imágenes procesadas y
categorizadas. Para hacer el modelo se presiona el botón Explorer de la
interfaz de Weka como se muestra en la Figura 8.
Figura 8. Interfaz Weka
30
En Weka Explorer se abre el archivo donde se guardó la categorización de las
imágenes presionando el botón Open file, en este caso es el archivo
“categorías 400.csv”. En la Figura 9 se observa el procedimiento.
Figura 9. Selección de Archivo “csv”
La mayoría de los algoritmos de Weka trabajan con clases nominales y no
numéricas. Para cambiar el tipo de clase es necesario aplicar un filtro no
supervisado que trabaje sobre los atributos del archivo de las categorías. En
la Figura 10 se muestra el filtro con el que se trabajó.
Figura 10. Filtro no supervisado para cambiar el tipo de clase.
31
Una vez aplicado el filtro se observa en la Figura 11 el cambio de numérico a
nominal en la clase.
Figura 11. Cambio de clase
Se probaron diferentes clasificadores o algoritmos para crear el modelo que
mejor se ajuste a las necesidades de la aplicación. Entre esos clasificadores
están IB1, Kstar, NaiveBayes, IBk entre otros. Los modelos obtenidos daban
problemas de compatibilidad con Android y la librería de Weka para Andorid
por lo cual no se pudo trabajar con esos modelos.
El clasificador o algoritmo con el que se pudo trabajar e implementar en
Android fue un árbol de decisión J48. En la Figura 12 se muestra el resultado
del algoritmo.
Figura 12. Resultado árbol de decisión.
32
En la Figura 13 se puede observar el árbol de decisiones de manera gráfica.
Figura 13. Árbol de decisión.
4.4 DESARROLLO DE LA APLICACIÓN ANDROID.
La aplicación está diseñada para conectarse automáticamente con el robot i-
Racer mediante la dirección MAC del robot. Consta de un menú de opciones
para elegir el objeto al que se desea seguir como se muestra en la Figura 14.
Figura 14. Menú de la Aplicación.
La aplicación funciona en dispositivos con cualquier resolución de pantalla.
Para lograr que el modelo desarrollado en Weka se ajuste a los diferentes
33
tipos de resoluciones de pantalla que existen Android se normalizaron las
coordenadas del objeto que se desea seguir.
La aplicación está basada en el programa ColorBlobDetector que viene
incluido como ejemplo en la biblioteca de OpenCv.
En la Figura 15 se muestra la parte principal del código del menú “Laser” el
cual permite identificar un punto luminoso mediante el uso de las librerías de
OpenCv.
Figura 15. Código Menú Laser
El resultado de la función MinMaxLocResult son las coordenadas del punto
más luminoso en la imagen que se está procesando. En la Figura 16 se
observa la imagen procesada e identificado el punto luminoso.
Figura 16. Resultado MinMaxLocResult en diferentes superficies.
34
El código del menú Binarizar se puede observar en la Figura 17. Este código
es el que mejores resultados dio ya que procesa la imagen y escoge el punto
luminoso dependiendo del área que este tenga. Este método utiliza la función
findContours de OpenCv lo que permite saber el área de los objetos
detectados y su posición.
Figura 17. Código del menú Binarizar
En la Figura 18 se observa el resultado del procesamiento de la imagen
utilizando las funciones de OpenCv.
Figura 18. Resultado por findContours en diferentes superficies.
35
En la Figura 19 se observa la parte principal del código para detectar objetos
por color. Está basado en la detección por Blobs que viene incluida como
ejemplo en la librería de OpenCv.
Figura 19. Código menú Otros
Esta sección de la aplicación requiere que el usuario pulse sobre un objeto en
la pantalla del dispositivo Android para analizar su color y marcar el objeto
para su seguimiento, como se ve en la Figura 20, donde se muestra el
resultado de este procedimiento.
Figura 20. Objeto marcados por color
36
Para dirigir al Robot se definieron las siguientes variables estáticas al inicio
del programa. En la Figura 21 se muestra la declaración de estas variables
que luego serán utilizadas en la implementación del árbol de decisiones y
dirigirán al robot de acuerdo a la posición del objeto.
Figura 21. Declaración de variables para direccionamiento del robot.
En la Figura 22 se observa la implementación del árbol de decisiones para 3
categorías. La implementación para las demás categorías es similar.
Figura 22. Código árbol de decisiones
4.5 FALSOS POSITIVOS. La aplicación fue probada en diferentes superficies. En superficies de alta
reflectancia como baldosa o cerámica no se detecta el objeto deseado. Como
se observa en la Figura 23.
37
Figura 23. Detección de falsos positivos por MinMaxLocResult de OpenCv
El problema anteriormente mencionado también se aplica para las funciones
utilizadas en el menú Binarizar, como se ve en la Figura 24.
Figura 24. Detección de falsos positivos por findContours de Opencv
38
CONCLUSIONES Y RECOMENDACIONES
5. CONCLUSIONES Y RECOMENDACIONES.
5.1 CONCLUSIONES
• La captura de imágenes debe ser en un entorno controlado, es decir la
luz debe ser la adecuada y no deben existir factores que puedan alterar
los resultados en el modelamiento como superficies de alta
reflectancia.
• Se decidió trabajar con imágenes de 640 x 480 pixeles ya que es la
resolución mínima ofrecida por la aplicación Cámara de Google y de
esta manera evitar más procesamiento de las imágenes.
• No se trabajó con resoluciones de imagen más pequeñas porque se
perdía mucha información en la imagen, al ser un punto luminoso el
objeto que se debe seguir.
• Se decidió trabajar con 400 imágenes porque daban los mejores
resultados con esta cantidad de instancias los algoritmos de Weka
incluido el árbol de decisiones.
• La captura y el procesamiento de imágenes se hizo con las librerías y
funciones de OpenCv lo que permite ahorrar recursos en dicho
procesamiento.
• La aplicación funciona de manera adecuada sobre superficies que no
posean alta reflectancia como baldosa y pisos de madera sin lacar
cumpliendo con los objetivos planteados.
5.2 RECOMENDACIONES
• La aplicación solo puede seguir un punto u objeto a la vez, al existir dos
puntos u objetos la aplicación se detiene. Para futuros trabajos sería
recomendable elegir uno de los objetos por sus características es decir
por tamaño, color o la característica más relevante.
39
• Para futuros trabajos es recomendable probar con otros algoritmos de
aprendizaje automático incluyendo imágenes con ruido o con varios
objetos para tener un índice menor de falsos positivos.
• Para incrementar el rendimiento de la aplicción es recomendable
trabajar con celulares con pantallas pequeñas debido a que la captura
de imágenes se la hace de acuerdo a la resolución de la pantalla del
dispositivo.
40
BIBLIOGRAFÍA
Abreu, A. (2013). Introduction to openCV as a way to train openMP. Instituo
Politécnico de Setúbal.
Albiol, A. J. (2013). Técnicas de filtrado de imágenes. Universitat Politécnica
de Valencia.
Allen, S., Graupera, V., & Lundrigan, L. (2010). Pro Smartphone Cross-
Platform Development : IPhone, Blackberry, Windows Mobile, and
Android Development and Distribution. Springer.
Bradsky, G., & Kaehler, A. (2008). Learning OpenCV : Computer Vision with
the OpenCV Library. O’Reilly Media.
Cameron, R. (2011). Pro Windows Phone 7 Development. Springer
Fachmedien.
Cyganek, B. (2013). Object Detection and Recognition in Digital Images :
Theory and Practice. EBL.
Datal, J., & Patel, S. (2013). Instant OpenCV Starter. Packt Publishing.
Dawson-Howe, K. (2014). A Practical Introduction to Computer Vision with
OpenCV. Wiley.
de la Caridad Rivero-Hernández, D., Salgueiro-Sicilia, Y., & Domínguez-
López, R. (2012). Evaluación de varias técnicas de aprendizaje
automático en el Software Weka. (Spanish). Valuation of several
learning techniques in the Weka software. (English), 18(3), 1-10.
Dingsoyr, T., Dyba, T., & Moe, N. B. (2010). Agile Software Development.
Springer.
41
Fisher, R. B., Breckon, T. P., Dawson-Howe, K., Fitzgibbon, A., Robertson,
C., Trucco, E., & Williams, C. K. I. (2013). Dictionary of Computer
Vision and Image Processing (2.a ed.). Hoboken: Wiley.
Gauglitz, S., Höllerer, T., & Turk, M. (2011). Evaluation of Interest Point
Detectors and Feature Descriptors for Visual Tracking. International
Journal of Computer Vision, 94(3), 335-360.
Helal, S., Bose, R., & Li, W. (2012). Mobile Platforms and Development
Environments. Morgan & Claypool Publishers.
Hightower, R., Onstine, W., Visan, P., Payne, D., Gradecki, J. D., Rhodes,
K., … Meade, E. (2004). Professional Java Tools for Extreme
Programming : Ant, XDoclet, JUnit, Cactus, and Maven. EBL.
Hunt, J. (2006). Agile Software Construction. Springer.
Introduction — OpenCV 2.4.8.0 documentation. (s. f.). Recuperado 9 de abril
de 2014, a partir de
http://docs.opencv.org/2.4.8/modules/core/doc/intro.html
Karam, P. A. (2011). Artificial Intelligence. Infobase Publishing.
Karch, M. (2010). Android for Work. Dordrecht: Springer.
Kononenko, I., & Kukar, M. (2007). Machine Learning and Data Mining.
Elsevier Science.
Krishnamurthy, N., & Saran, A. (2007). Building Software : A Practitioner’s
Guide. Taylor and Francis.
Laganiere, R. (2011). OpenCV 2 Computer Vision Application Programming
Cookbook. Packt Publishing.
Lantz, B. (2013). Machine Learning with R. Packt Publishing.
42
Lo, D., Khoo, S.-C., Han, J., & Liu, C. (2011). Mining Software
Specifications : Methodologies and Applications. Chapman &
Hall/CRC Data Mining and Knowledge Discovery Series.
Montabone, S. (2010). Beginning Digital Image Processing : Using Free
Tools for Photographers. Berkeley, CA: Apress.
Münch, J., Armbrust, O., & Kowalczyk, M. (2012). Software Process
Definition and Management. EBL.
Pertusa Grau, J. F. (2011). Técnicas de análisis de imagen: Aplicaciones en
Biología (2da ed.). Universitat de València.
Pulli, K., Baksheev, A., Kornyakov, K., & Eruhimov, V. (2012). Real-Time
Computer Vision with OpenCV. Association for Computing Machinery.
Communications of the ACM, 55(6).
Ramanna, S., Jain, L. C., & Howlett, R. J. (2012). Emerging Paradigms in
Machine Learning. Springer.
Ranchordas, A. K., Pereira, J. M., Araujo, H. J., & Tavares, J. M. R. S.
(2010). Computer Vision, Imaging and Computer Graphics : Theory
and Applications. Dordrecht: Springer.
Russ, J. C. (2011). The Image Processing Handbook, Sixth Edition (6.a ed.).
Taylor and Francis.
Savitha, G., Venugopal, P. S., Sarojadevi, & Chiplunkar, N. (2014). An
Approach for Object Detection in Android Device. En 2014 Fifth
International Conference on Signal and Image Processing (ICSIP) (pp.
9-14).
43
Sebe, N., Cohen, I., & Garg, A. (2006). Machine Learning in Computer
Vision. Springer.
Shih, G., Lakhani, P., & Nagy, P. (2010). Is Android or iPhone the Platform
for Innovation in Imaging Informatics. Journal of Digital Imaging, 23(1),
2-7.
Shi, Z. (2011). ADVANCED ARTIFICIAL INTELLIGENCE. World Scientific
Publishing Company.
Structural Analysis and Shape Descriptors — OpenCV 2.4.11.0
documentation. (2015). Recuperado 10 de junio de 2015, a partir de
http://docs.opencv.org/2.4.11/modules/imgproc/doc/structural_analysis
_and_shape_descriptors.html?highlight=findcontours#cv.FindContour
s
Suzuki, S., & Abe, K. (1985). Topological Structural Analysis of Digitized
Binary Images by Border Following, 32-46.
The University of Waikato. (2014). Weka 3 - Data Mining with Open Source
Machine Learning Software in Java. Recuperado 26 de junio de 2014,
a partir de http://www.cs.waikato.ac.nz/ml/weka/index.html
Wang, D., Lu, H., Xiao, Z., & Chen, Y. (2013). Fast and effective color-based
object tracking by boosted color distribution. Pattern Analysis and
Applications, 16(4), 647-661.
Wang, Y. (2007). Software Engineering Foundations : A Software Science
Perspective. Taylor and Francis.
Wei, X.-X., & Meng, L. (2013). A Method to Implementation of Lane Detection
Under Android System Based on OpenCV. En J. Juang & Y.-C. Huang
44
(Eds.), Intelligent Technologies and Engineering Systems (pp. 115-
121). Springer New York.
Westfall, J. (2011). Windows Phone 7 Made Simple. Springer.
Witten, I. H., Frank, E., & Hall, M. A. (2011). Data Mining : Practical Machine
Learning Tools and Techniques (3.a ed.). Burlington: Elsevier Science.
Zelinsky, A. (2009). Learning OpenCV—Computer Vision with the OpenCV
Library (Bradski, G.R. et al.; 2008)[On the Shelf]. IEEE Robotics
Automation Magazine, 16(3), 100-100.
45