Reconocimiento de color y posición con un sensor Kinect ...

TRABAJO DE GRADO 1548

Reconocimiento de color y posicion con un sensorKinect para aplicacion de robotica movil

Paola Andrea Garcıa PreciadoSergio Nicolas Gonzalez Forero

Director:Ing. Julian D. Colorado, Ph.D.

Co-director:Ing. Ivan F. Mondragon, Ph.D.

Pontificia Universidad JaverianaFacultad de Ingenierıa

Departamento de ElectronicaBogota D.C., Colombia

2016

Agradecimientos

Gracias a DIOS y a nuestras familias, en especial a nuestros padres. Gracias a todosellos hemos llegado tan lejos.

Agradecimientos a todo el equipo de JaVEX, especialmente a los hermanos Oscar yNestor Ribero por su ayuda y paciencia; A Juan Jose Martınez Moritz que sin el, esteproyecto no habrıa sido posible.

Gracias a Juan Sebastian Adame por sus ideas innovadoras a lo largo de nuestracarrera.

Gracias a todos nuestros grandes amigos con los que estuvimos luchando juntos poresta victoria.

ResumenSe disena un sistema de vision artificial para una aplicacion de robotica movil, logrando ensamblar y con-trolar un robot de prueba capaz de identificar y recoger objetos esfericos de color verde y naranja. En esteproyecto se utiliza una tarjeta de desarrollo Raspberry Pi para procesar las imagenes y datos de profundidadadquiridos con un sensor Kinect, y se establece una comunicacion serial para transmitir esta informacion a unmicrocontrolador ARM Cortex de VEX. En el desarrollo del sistema de vision artificial se compararon tresalgoritmos de reconocimiento de bordes: el metodo de Canny, el metodo de Sobel y el metodo Laplaciano,tambien se compararon tres filtros de color, utilizando los espacios de color HSV, HSL y Lab; se concluyoque los mejores algoritmos con menor tiempo de ejecucion para la aplicacion robotica fueron el filtro decolor en el espacio Lab y el metodo Laplaciano para el reconocimiento de bordes. El microcontrolador y elsensor Kinect se alimentaron con baterıas de niquel e hidruro metalico (Ni-MH) con la respectiva regulacionpara el sensor Kinect; para alimentar la tarjeta de desarrollo Raspberry Pi, se utilizo una baterıa de iones delitio (LiPo), de este modo se pudieron transportar todos los componentes dentro del robot de prueba y secontrolo inalambricamente mediante una antena VEXnet2.0, obteniendo un robot inalambrico y autonomocapaz de identificar en un 88.3 % de efectividad sus objetivos.

Palabras clave: Procesamiento de imagenes; Sistemas embebidos; Sistema de vision robotica; algoritmos de de-teccion; Medicion de distancias.

I

AbstractIs designed an artificial vision system for a mobile robotics application, being able to assemble and con-trol a test robot capable of identify and collect spherical objects of green and orange color. In this project aRaspberry Pi development board is used to process the images and depth data acquired with a Kinect sensor,and is achieved a serial communication to transmit this information to a VEX ARM Cortex-based micro-controller. In the development of the artificial vision system there were compared three algorithms of edgedetection: the Canny’s method, the Sobel’s method and the Laplacian method, there were also compared th-ree color filters, using the HSV, HSL and Lab color spaces; it was concluded that the best algorithm with theshortest execution time for the robotic application, was the color filter using the Lab space and the Laplacianmethod for the edge detection. The VEX ARM Cortex-based microcontroller and the Kinect sensor were fedby Nickel-metal hydride batteries (Ni-MH) with the respective regulation for the Kinect sensor; for feedingthe Raspberry Pi development board, it was used a lithium ion battery (LiPo), in this way it was able to carryall the components in the test robot and it was wireless controlled using a VEXnet2.0 antenna, obtaining awireless and an autonomous robot capable to identify with an 88.3 % of effectiveness his targets.

Keywords: Image processing; Embedded systems; Robotic vision systems; Detection algorithms; Distance mea-surement.

II

Indice general

Resumen I

Lista de figuras VI

Lista de tablas VII

1. INTRODUCCION 1

2. MARCO TEORICO 32.1. Espacios de color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.1.1. Espacio HSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.1.2. Espacio HSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.1.3. Espacio Lab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2. Procesamiento de imagenes binarias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.1. Erosion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.2. Dilatacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.3. Deteccion de bordes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.3.1. Metodo Laplaciano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.3.2. Metodo de Sobel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.3.3. Metodo de Canny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.4. Segmentacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.4.1. Algoritmo HoughCircles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.5. Plataforma VEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.5.1. Robot movil diferencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.5.2. Control on-off . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.6. Sensor Kinect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.7. Tarjeta de desarrollo Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3. OBJETIVO DEL PROYECTO 193.1. Desempeno del proyecto ante los objetivos especıficos . . . . . . . . . . . . . . . . . . . . 193.2. Solucion del problema definido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4. DESARROLLO 214.1. Desarrollo del software en la Raspberry Pi . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.1.1. Filtros de Color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.1.2. Deteccion de bordes y reconocimiento de forma . . . . . . . . . . . . . . . . . . . . 264.1.3. Interpretacion de los valores de profundidad del sensor Kinect . . . . . . . . . . . . 27

4.2. Desarrollo del software en el microcontrolador ARM Cortex de VEX . . . . . . . . . . . . 324.2.1. Control on-off de distancia: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.2.2. Control on-off de giro: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.3. Comunicacion serial entre Raspberry Pi y ARM Cortex de VEX . . . . . . . . . . . . . . . 344.4. Arquitectura del robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5. PROTOCOLO DE PRUEBAS 38

6. ANALISIS DE RESULTADOS 416.1. Resultados de la evaluacion del sistema de vision artificial . . . . . . . . . . . . . . . . . . 416.2. Evaluacion del robot de prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

III

7. CONCLUSIONES Y RECOMENDACIONES 477.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477.2. Recomendaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

8. REFERENCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

9. Anexos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

A. Anexos 51A.1. Codigo del procesamiento de imagenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51A.2. Codigo de Python para la comunicacion serial . . . . . . . . . . . . . . . . . . . . . . . . . 56A.3. Codigo de RobotC para el microcontrolador ARM Cortex de VEX . . . . . . . . . . . . . . 58A.4. Codigo de obtencion de datos de los motores con RobotC . . . . . . . . . . . . . . . . . . . 64A.5. Resultados de las pruebas ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66A.6. Desempeno del robot de Prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

IV

Indice de figuras

1.1. Contexto de la competencia Nothing but Nets de VEX robotics . . . . . . . . . . . . . . . . 1

2.1. Interpretacion grafica de HSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2. Variacion del matiz en HSV con saturacion y brillo maximo . . . . . . . . . . . . . . . . . 42.3. Saturacion en HSV con matiz en 0o y brillo maximo . . . . . . . . . . . . . . . . . . . . . . 42.4. Brillo en HSV con saturacion maxima y matiz de 90o . . . . . . . . . . . . . . . . . . . . . 52.5. Interpretacion grafica de HSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.6. Saturacion en HSL con luminosidad del 50 % y matiz de 0o . . . . . . . . . . . . . . . . . . 52.7. Luminosidad en HSL con saturacion del 100 % y matiz de 10o . . . . . . . . . . . . . . . . 62.8. Interpretacion grafica de Lab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.9. Canales del espacio de color Lab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.10. Tipos de bordes descritos en una dimension . . . . . . . . . . . . . . . . . . . . . . . . . . 92.11. Modo en que actua el filtro laplaciano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.12. Angulos detectados por Canny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.13. Microcontrolador ARM Cortex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.14. Diagrama de conexion Coxtex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.15. Disco interno del encoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.16. Modelo diferencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.17. Control On-Off . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.18. Componentes principales del Sensor Kinect . . . . . . . . . . . . . . . . . . . . . . . . . . 172.19. Angulos que detecta el sensor Kinect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.20. Tarjeta de desarrollo Raspberry Pi 3 Model B . . . . . . . . . . . . . . . . . . . . . . . . . 172.21. Diagrama de Pines GPIO de la Raspberry Pi 3 Model B . . . . . . . . . . . . . . . . . . . . 18

3.1. Robot de prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4.1. Diagrama de bloques del trabajo de grado . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.2. Imagenes RGB y de profundidad depth adquiridas por el sensor Kinect . . . . . . . . . . . . 224.3. Muestras de color tomadas con el sensor Kinect . . . . . . . . . . . . . . . . . . . . . . . . 234.4. Histogramas de dos muestras de color naranja para determinar los rangos en los espacios de

color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.5. Histogramas de dos muestras de color verde para determinar los rangos en los espacios de

color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.6. Izquierda imagen binaria filtrada en espacio HSV a la izquierda; Derecha Imagen RGB con

filtro mediana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.7. Izquierda imagen binaria filtrada y con opening a la izquierda; Derecha Imagen RGB original 264.8. Borde detectado con el metodo de Canny . . . . . . . . . . . . . . . . . . . . . . . . . . . 264.9. Dibujo de la circunferencia con el radio y el centro encontrado con el metodo de Hough . . . 274.10. Desalineacion entre la imagen RGB y Depth del sensor Kinect . . . . . . . . . . . . . . . . 274.11. Verificacion de la alineacion de la imagen RGB y la imagen de profundidad . . . . . . . . . 284.12. Comparacion de los datos de profundidad reales con los datos aproximados . . . . . . . . . 294.13. Deteccion de los objetivos con su respectiva distancia . . . . . . . . . . . . . . . . . . . . . 314.14. Explicacion de la geometrıa para hallar las coordenadas de los objetivos . . . . . . . . . . . 314.15. Caracterizacion de los dos motores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.16. Tecnica de giro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.17. Trama de datos para enviar en transmision serial . . . . . . . . . . . . . . . . . . . . . . . . 344.18. Senales de comunicacion entre la Raspberry Pi y el microcontrolador VEX . . . . . . . . . 354.19. Arquitectura del robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

V

4.20. Arquitectura del robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.21. Regulacion de 12 V para el sensor Kinect . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.1. Prueba para medicion del tiempo de ejecucion de algoritmos . . . . . . . . . . . . . . . . . 385.2. Muestras para evaluar el sistema de vision artificial . . . . . . . . . . . . . . . . . . . . . . 395.3. Ejemplo de la prueba 3 para evaluar el sistema de vision artificial . . . . . . . . . . . . . . . 40

6.1. Comparacion entre los tres algoritmos de deteccion de bordes . . . . . . . . . . . . . . . . . 416.2. Comparacion entre los tres filtros de color . . . . . . . . . . . . . . . . . . . . . . . . . . . 426.3. Tiempos de ejecucion de todo el sistema de vision, usando los algorimtos de deteccion de

bordes y deteccion de color. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436.4. Tiempos del filtro Lab y de la deteccion de bordes con metodo Laplaciano . . . . . . . . . . 436.5. Comparacion entre las tres curvas ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

A.1. Datos adquiridos para la caracterizacion de los motores . . . . . . . . . . . . . . . . . . . . 65A.2. Datos registrados de las pruebas ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66A.3. Datos registrados de las pruebas ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66A.4. Datos registrados de las pruebas ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66A.5. Datos registrados del desempeno del robot de prueba . . . . . . . . . . . . . . . . . . . . . 67A.6. Datos registrados del desempeno del robot de prueba . . . . . . . . . . . . . . . . . . . . . 68A.7. Datos registrados del desempeno del robot de prueba . . . . . . . . . . . . . . . . . . . . . 69A.8. Datos registrados del desempeno del robot de prueba . . . . . . . . . . . . . . . . . . . . . 70A.9. Datos registrados del desempeno del robot de prueba . . . . . . . . . . . . . . . . . . . . . 71

VI

Indice de tablas

4.1. Rango de maximos y mınimos para cada canal en cada espacio de color para las muestrasnaranjas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.2. Rangos utilizados en Python para los filtros en los diferentes espacios de color . . . . . . . . 254.3. Comparacion de los valores obtenidos con medidas y con dos aproximaciones . . . . . . . . 30

6.1. Resultado ideal de una prueba ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446.2. Tablas de resultados de las pruebas ROC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

VII

1. INTRODUCCIONEl procesamiento de imagenes es ampliamente aplicado en el area de la robotica, se han utilizado para quelos robots puedan realizar sus tareas asignadas, como por ejemplo utilizar el reconocimiento de color y for-mas para detectar los objetivos de un robot [1], o para evitar obstaculos registrando las distancias de patronesy figuras del entorno como lo hacen algunos robots moviles [2]. En particular, un grupo de estudiantes deIngenierıa Electronica de la Pontificia Universidad Javeriana, desarrollaron unos robots a partir de piezas ydispositivos de VEX robotics, empresa organizadora de competencias roboticas a nivel nacional e internacio-nal [3]. Basados en los robots que se desarrollaron para la competencia Nothing But Net [4], se implementaraun sistema de vision artificial para determinar la posicion y el color de los objetivos del robot, que son pe-lotas verdes y naranjas. Este sistema se implementara sobre un robot de prueba por fuera del contexto de lacompetencia de VEX robotics antes mencionada.

A partir de la competencia Nothing But Net de VEX robotics [4], cuyo contexto se puede observar en la Fi-gura 1.1, se puede apreciar que el Robot VEX debe reconocer los objetivos que estan ubicados a su alrededor,determinando la posicion coordenada (x, y) y el color de las esferas ubicadas en la pista, dandole prioridad alas pelotas naranjas sobre las verdes ya que estas dan un mayor puntaje al lanzarlas a la red correspondientedel equipo, en este proyecto se realizo el sistema de reconocimiento y se evaluo sobre un robot de pruebafuera del contexto de la competencia.

Figura 1.1: Contexto de la competencia Nothing but Nets de VEX robotics

La plataforma robotica funciona con un microcontrolador VEX ARM Cortex y se utilizo un robot de pruebacon piezas VEX para probar el sistema de vision artificial, detectando la posicion de las esferas y recono-ciendo si la pelota es verde o naranja; para ello se visualiza mediante unos leds si la pelota que atrapa elrobot es verde o naranja, encendiendo un led verde o uno rojo respectivamente.

Se han desarrollado varias soluciones en el mundo para la deteccion de distancia, color y bordes mediantevision artificial, como se explica en un proyecto donde se aplican algoritmos de reconocimiento de forma ycolor en una plataforma robotica [1]. Se destacan problemas como sombras, cambio de luz y caracterısticasde la camara con que se adquieren las imagenes. Estos problemas pueden variar dependiendo de los modelosempleados, tales como el RGB (rojo verde y azul, por sus siglas en ingles), el HSL (Matiz, saturacion eintensidad, por sus siglas en ingles), entre otros espacios de color existentes. Es necesario aplicar algoritmosde segmentacion para el reconocimiento de la forma.

1

Otro desarrollo que ha contribuido al area de vision artificial es la deteccion de distancias. Se han planteadosoluciones utilizando camaras y sensores como el Kinect de Microsoft, como el proyecto desarrollado porOmar Rodrıguez, Antonio Hernandez y Jorge Adalberto Huertas, donde se realizo un sistema de medicionde distancia mediante imagenes para determinar la posicion de una esfera [5]. El metodo que utilizan en elproyecto para medir la distancia que tiene una esfera respecto a la base de una columna de acrılico trans-parente, es utilizando medidas de referencia, como la distancia total de la columna. Realizan una serie dealgoritmos para que la columna quede completamente vertical en la imagen y reconociendo el color rojo dela esfera y midiendo la profundidad a la que esta la columna, hallan el centroide de la esfera y respecto a laposicion que tenga dentro de la columna, hallan la distancia respecto a la base de esta.

Una aplicacion del reconocimiento de formas y color, es la capacidad de realizar un seguimiento a algunobjeto, como en el caso del proyecto desarrollado por Jini Mao, donde se sigue una pelota de tenis utilizandotecnicas de procesamiento de imagenes [6]. A lo largo del trabajo citado se realizan tecnicas de deteccionde bordes y deteccion de contorno mediante el operador de Laplace, se utilizan tambien la tecnica del filtromediana, donde se reduce el ruido de la imagen y la tecnica de operadores morfologicos que combina vecto-res, consiguiendo el efecto de dilatacion que sirve para ampliar la imagen con pocas perdidas en sus detalles.Otro metodo que se realiza es la deteccion de formas analıticamente definidas como cırculos y lıneas me-diante la transformada de Hough.

En este trabajo de grado se pretende identificar el centroide de unas esferas y sus bordes para seleccionarlos datos de distancia del objetivo y determinar de este modo la coordenada que tiene la esfera respecto a lacamara; para ello se necesitan algoritmos similares a los destacados anteriormente. Se debe realizar un pro-cesamiento de imagen en tiempo real, aplicando conjuntamente la deteccion de borde, la deteccion de colory la seleccion de pixeles de distancia correspondientes al objetivo para enviar constantemente la informaciona la plataforma robotica tal como se describe a continuacion en los objetivos del trabajo.

Objetivo General:Implementar algoritmos de procesamiento de imagenes para reconocimiento de posicion y color de objetosespecıficos, evaluandolos con un robot de prueba.

Objetivos Especıficos:

1. Evaluar y comparar tres algoritmos de procesamiento de imagenes para reconocer los bordes de unasesferas utilizadas como objetivos y seleccionar el algoritmo con mayor velocidad de procesamiento yverificar con un algoritmo si el contorno hallado corresponde a una circunferencia o no.

2. Implementar y comparar tres metodos de reconocimiento de color para determinar si las esferas detec-tadas son naranjas o verdes y seleccionar el metodo con mayor velocidad de procesamiento.

3. Determinar con los datos adquiridos por la camara infrarroja del sensor Kinect, la posicion coordenadaen la que se encuentran las esferas detectadas con el reconocimiento de bordes y evaluar la exactitudde la medida.

4. Disenar y ensamblar un robot de prueba que ejecute unas rutinas especıficas programadas y controla-das a traves de una tarjeta de desarrollo Rasperry pi, utilizando el sistema de vision artificial que sedesarrollara en el presente trabajo de grado.

2

2. MARCO TEORICOUna imagen es conformada digitalmente por una serie de valores matriciales, por ejemplo una matriz comola de la ecuacion (2.1), podrıa representar una imagen de escala de grises, donde cada elemento de G esconsiderado un pixel y donde axy toma valores entre un rango de 0 y 255, cuando cada pixel de la matriz seconsidera de 1 byte (8 bits). Teniendo en cuenta esta informacion, se puede decir que si un valor axy se aceraa 0, significa que ese pixel es mas oscuro, mientras que si se acerca a 255, el pixel es mas claro. Cuandosolo existen esos dos valores (0 y 255), se considera una imagen binaria, es decir de solo blanco y negro. Laresolucion de una imagen es conocida como los valores de m y n, es decir, las dimensiones de la matriz G.

G =

a11 a12 a13 · · · a1na21 a22 a23 · · · a2na31 a32 a33 · · · a3n

......

.... . .

...am1 am2 am3 · · · amn

(2.1)

Por otro lado, una imagen de color es una matriz que contiene tres matrices con la forma de G de la ecuacion(2.1), en donde cada matrizR,G yB, representan la intensidad en la imagen de los colores rojo, verde y azulrespectivamente, que al combinarse estos colores, se puede generar toda una gama de colores que percibe elser humano. En este caso, un pixel serıa representado por tres valores (rxy, gxy, bxy) indicando la intensidadde cada color, tal como se muestra en la ecuacion (2.2).

RGB =

R =

r11 r12 r13 · · · r1nr21 r22 r23 · · · r2nr31 r32 r33 · · · r3n

.

.

....

.

.

.. . .

.

.

.rm1 rm2 rm3 · · · rmn

G =

g11 g12 g13 · · · g1ng21 g22 g23 · · · g2ng31 g32 g33 · · · g3n

.

.

....

.

.

.. . .

.

.

.gm1 gm2 gm3 · · · gmn

B =

b11 b12 b13 · · · b1nb21 b22 b23 · · · b2nb31 b32 b33 · · · b3n

.

.

....

.

.

.. . .

.

.

.bm1 bm2 bm3 · · · bmn

(2.2)

Ahora bien, ya que se conoce la estructura de una imagen, se puede explicar el resto de conceptos que hayque tener en cuenta para la comprension del procesamiento de imagenes desarrollado en el trabajo de grado.

2.1. Espacios de colorHay varias maneras en que se puede describir una imagen, una de ellas es la que se describio anteriormentey es el espacio RGB, el cual se utiliza bastante debido a que fısicamente cada pixel en una pantalla es repre-sentado por la cantidad de intensidad que se le aplique para cada color, y la pantalla completa se describecomo la matriz de la ecuacion (2.2). Sin embargo, esta matriz puede transformarse de varias maneras digi-talmente, modificando los valores RGB y transformando las matrices R, G y B, para obtener otros espaciosde color y ası representar la imagen con otra matriz que contenga los valores del nuevo espacio de color,matematicamente las transformaciones se pueden apreciar en la referencia [7]. A continuacion se describiranlos espacios de color que se utilizan en el presente trabajo de grado.

2.1.1. Espacio HSVEl modelo HSV es un espacio de color que al igual que el espacio RGB descrito en la ecuacion (2.2), esrepresentado con tres componentes que son H, S y V, que por sus siglas en ingles corresponden al tonoo matiz (Hue), saturacion (Saturation) y brillo o valor (Value) [7, pp. 110-111]. Estas tres magnitudes serepresentan por medio de un diagrama cilındrico que contiene la informacion necesaria para hallar el colordeseado. El tono o matiz esta representado por un angulo que recorre el cilindro sobre su eje, el valor estanrepresentados el eje vertical del cilindro y la saturacion por el eje horizontal, como se puede observar en lafigura 2.1 tomada de [7, pp. 111] se pueden apreciar la interpretacion grafica del espacio HSV.

3

Figura 2.1: Interpretacion grafica de HSV

HUE – Tono o MatizLa gama cromatica se representa por medio del valor del angulo del matiz respecto al eje del cilindro, don-de cada angulo representa un color diferente. En el caso de ser programado en Python con la biblioteca deOpenCV [8] este valor varıa entre 0o a 180o puesto que si se trabajara con 360o, este valor supera el valorde 255, que es el valor maximo de un pixel en el formato llamado uint8 que utiliza unicamente 8 bits [9]. Sepuede observar en la figura 2.2, como varıa el color al variar el angulo, manteniendo constante la saturaciony el brillo en 255 (100 %).

Figura 2.2: Variacion del matiz en HSV con saturacion y brillo maximo

Saturation – SaturacionLa saturacion indica la escala de grises en el espacio de color. Los valores varıan de 0 % a 100 %. Al aumen-tar este parametro, se obtiene un color mas vivo, mientras que al disminuirlo, el color tiende al blanco. Enla figura 2.3 se puede apreciar como se comportan los cambios de este componente, tomando como ejemploun tono rojo de matiz 0o y un brillo (value) maximo (255) y variando la componente de saturacion.

Figura 2.3: Saturacion en HSV con matiz en 0o y brillo maximo

Estos valores en OpenCV varıan entre 0 y 255, para representar el rango mencionado anteriormente de 0 %a 100 % de saturacion [9].

Value – ValorEl valor o brillo es el grado de luminosidad del color que al igual que la saturacion, varıa entre 0 % y 100 %.Cuando lo valores estan cercanos a 0 el espacio de color estara en la tonalidad oscura en cambio, mientrasmas grande sea el valor, va disminuyendo la oscuridad. En la figura 2.4 se puede apreciar como aumenta el

4

brillo del azul, que corresponde a un angulo de matiz de 90o y utilizando una saturacion del 100 %.

Figura 2.4: Brillo en HSV con saturacion maxima y matiz de 90o

2.1.2. Espacio HSLEl modelo HSL es un espacio de color que tiene tres componentes: matiz, saturacion y luminosidad [7,pp. 114-115]. Es similar al modelo HSV, lo que varıa es la distribucion de saturacion y luminosidad, mien-tras que el matiz se mantiene con la misma distribucion de la figura 2.2. La saturacion y la luminosidad queserıa el equivalente al brillo de HSV cambian su distribucion.

En la siguiente figura 2.5 tomada de [10] se puede observar la representacion del modelo HSL, con su res-pectiva forma cilındrica, donde el color se representa mediante el mismo angulo de HSV, la saturacion y laluminosidad se representa mediante dos ejes, el que va del centro hacia afuera del cilindro horizontalmente(saturacion) y el que va de abajo hacia arriba desde la base del cilindro (luminosidad).

Figura 2.5: Interpretacion grafica de HSL

HUE – MatizEste componente determina que color del circulo cromatico se desea. Se representa por medio un circulo de360 grados. Donde 0 grados se identifica el color rojo y ası se va variando para poder obtener las diferentestonalidades.

Saturation – SaturacionLa distancia desde el centro del circulo hasta el borde es conocida como saturacion, este va desde el com-ponente totalmente saturado (100 %) hasta el gris(0 %). En la figura 2.6 se puede observar como varia lasaturacion del color manteniendo la luminosidad en el 50 % y el matiz en 0o (rojo).

Figura 2.6: Saturacion en HSL con luminosidad del 50% y matiz de 0o

Lightness – LuminosidadEsta componente se define como el grado de oscuridad o claridad que se desea de una tonalidad, esto de-pende de la cantidad de luz que se quiere para el color. Como se muestra en el diagrama de la figura 2.5 es

5

un gradiente de color que va desde la parte inferior del cilindro como negro hasta la parte superior comoblanco. Utilizando un color naranja (matiz de 10o) y una saturacion maxima, se observa el cambio de laluminosidad en la figura 2.7 que resulta similar a lo que se ve en la seccion naranja del cilindro de la figura2.5 recorriendolo verticalmente de abajo hacia arriba.

Figura 2.7: Luminosidad en HSL con saturacion del 100% y matiz de 10o

2.1.3. Espacio LabEste espacio es el segundo modelo de color uniforme estandarizado por la Comicion Internacional de Ilumi-nacion (por sus siglas en frances) [7, 11]. Este espacio de color fue creado para describir los colores visiblespara el ojo humano a partir de tres componentes (L,a y b) [7, pp. 116-117]. La teorıa conciste en que dos colo-res que son el magenta y verde o amarillo y azul al combinar sus intensidades se puede generar cualquier otrocolor. Lab es un modelo que esta compuesto por tres valores numericos o tres canales, que corresponden a laluminosidad (L) y a dos coordenadas cromaticas (a y b), la primera varıa entre el magenta y el verde (a) y lasegunda entre amarillo y azul a. Estos tres ejes crean el espacio de color en tres dimensiones [7, pp. 116-117].

Una representacion grafica se puede observar en la figura 2.8 tomada de [12] donde el eje L vertical repre-senta la luminosidad que va desde lo mas oscuro hasta lo mas claro dentro de un rango de 0 % a 100 % queen python, con OpenCV, serıan valores entre 0 y 255 [9]. Los ejes horizontales representados por a* y b*son angulos rectos que se cruzan en el centro con el eje de luminosidad. en el eje a* un extremo es verde,que corresponde a -a* y el otro es magenta descrito como +a*. Para el eje b* un lado es azul que es -b* y elotro es amarillo que es +b*.

Figura 2.8: Interpretacion grafica de Lab

En python, los rangos de cada canal son de 0 a 255 para cada uno, donde el centro ventıa a ser el valor de128 [9]. Con esta informacion, se pueden obtener los ejes L*, a* y b* de manera independiente variando elvalor de un solo eje y manteniendo constantes los otros dos ejes. Por ejemplo, variando L* entre 0 y 255, ymanteniendo a* y b* con valores de 128, se obtiene la variacion de L de la figura 2.9. Del mismo modo paraa*, manteniendo L* y b* en valores de 128 se puede observar como varıa el color de verde a magenta sonlos colores mencionados anteriormente, al igual que se obtiene el azul y el amarillo para el canal b*.

6

Figura 2.9: Canales del espacio de color Lab

Lab posee una ventaja con la luminosidad, ya que al cambiar la intensidad de luz del entorno, la captura decolor no se afecta tanto como en otros espacios de color.

2.2. Procesamiento de imagenes binariasAl aplicar un filtro de color, o cualquier otro tipo de segmentacion de una imagen (ver seccion 2.4), general-mente se obtiene una imagen binaria (en blanco y negro), donde la region de interes son los pixeles blancos.Sin embargo, no siempre esos pıxeles logran conformar toda la region de interes y quedan espacios en negroque deberıan ser blancos o en caso contrario, quedan espacios en blanco que no corresponden a la region deinteres, por lo que el proceso que hay que realizar es primero eliminar esas regiones blancas que deberıanser negras y despues, agregar las partes blancas que sı corresponden a la region de interes.

Debido a que las imagenes binarias que se utilizan en este trabajo de grado las regiones de interes son lasde colores naranja y verde, y como los objetos de estos colores deberıan ser cırculos, se debe implementarun post-procesamiento que logre dejar las regiones de interes en la imagen binaria con una forma circular,sin ningun tipo de partes negras dentro de la circunferencia. Para garantizar esto es posible utilizar unosoperadores morfologicos que se describiran a continuacion [13, pp. 61-70].

2.2.1. ErosionEste operador morfologico sirve para eliminar regiones blancas en la imagen que no son parte de la region deinteres, para ello, se utiliza una matriz binaria con valores de 255 o 0 con una forma deseada segun la formade los objetos que se quieren detectar, esta matriz de erosion E que recorre la imagen I ubicando el centrode E en cada pixel de I y verificando que toda la matriz E pertenezca a I , es decir que todos los valores de255 de la matriz E coincidan con los valores de 255 de la matriz I , dando como resultado la matriz R, de talmodo que si la matriz de erosion coincide con todos los valores de I se coloca un valor en R de 255, en casocontrario se coloca un valor de 0.

Para entender mejor este proceso se puede observar un ejemplo donde la matriz E al recorrer y comparar losvalores con la matriz I se obtiene el resultado que serıa la region de interes R con las mismas dimensionesde I . La operacion de erosion se expresa como R = I E y se puede observar el resultado en la ecuacion(2.3) del ejemplo [13, pp. 63-69].

Ejemplo:

I =

255 255 0 0 255 255255 255 255 0 0 2550 255 0 0 255 00 0 255 255 255 2550 0 0 255 255 0

E =

0 255 0255 255 2550 255 0

7

R = I E

R =

255 0 0 0 0 2550 255 0 0 0 00 0 0 0 0 00 0 0 0 255 00 0 0 0 0 0

(2.3)

Hay que tener en cuenta, que cuando se posiciona el nucleo (matriz E) en los bordes de la imagen I , sedebe interpolar o rellenar los valores inexistentes que hay alrededor toda la imagen para poder comparar losvalores del nucleo con los valores indefinidos de I . OpenCV tiene varios tipos de interpolacion para asig-narle valores a las posiciones por fuera del borde de la imagen, la interpolacion utilizada en este trabajo degrado es llamada BORDER CONSTANT, que consiste en rodear a la imagen con valores constantes maxi-mos (255) [14], de este modo se eliminan ciertos valores de la imagen binaria y se mantienen aquellos quecoinciden completamente con el nucleo utilizado.

2.2.2. DilatacionEste operador realiza practiamente lo contrario a la erosion, y lo que hace es recorrer la imagen con la matrizutilizada como mascara y en caso de que algun valor maximo (255) de la imagen coincida con cualquiervalor maximo de la mascara, se coloca en la imagen binaria resultante un valor maximo, de este modo seagranda la region de interes, y se pueden rellenar los huecos que haya dentro de la region [13, pp. 63-69].

Para asimilar mejor este concepto, se puede observar el siguiente ejemplo, utilizando las mismas matrices Ee I del ejemplo anterior, al aplicar dilatacion se obtiene R = I ⊕ E, en este caso el valor constante de lainterpolacion BORDER CONSTANT de OpenCV, asigna el valor de cero a todos los datos alrededor de laimagen [14], por lo que se puede deducir de antemano que los valores ubicados en la parte inferior izquierdade la matriz I , van a tener un valor mınimo (0) ya que para que resulte un valor en 0, la imagen I debe tenerunos ceros distribuidos en cruz del mismo modo que la matriz E, que por la interpolacion utilizada, esto secumple, el resto de la imagen sı queda con valores maximos de 255.Ejemplo:

R = I ⊕ E

R =

255 255 255 255 255 255255 255 255 255 255 255255 255 255 255 255 2550 255 255 255 255 2550 0 255 255 255 255

(2.4)

Con estos operadores morfologicos se puede conseguir un mejor resultado, eliminando posibles deteccioneserroneas aplicando erosion y luego suavizando y unificando la region de interes aplicando dilatacion. Esteproceso de utilizar primero erosion y al resultado aplicarle dilatacion se conoce como opening, al caso con-trario, invirtiendo la secuencia se conoce como closing. En el presente trabajo de grado, solo se utilizo lasecuencia de opening, cuya utilidad fue de suavizar y unificar la region de interes, utilizando a su vez unnucleo con forma circular que se explicara mas adelante en el desarrollo.

8

2.3. Deteccion de bordesLa deteccion de bordes consiste principalmente en obtener una imagen binaria con la forma de (2.1), pararepresentar los bordes de una imagen. A lo largo del desarrollo del presente trabajo de grado, los valoresmaximos o blancos representaran el borde de la imagen, mientras que los valores mınimos o negros repre-sentaran el fondo de la imagen.

En una imagen existen varios tipos de bordes que pueden ser nombrados como tipo rampa, linea, techo ypaso como se aprecian en la figura 2.10 tomada de [13, pp. 141], Estos bordes son generalmente un cambioabrupto de los valores de los pixeles de la imagen y son justamente los pixeles de dicho cambio los que sedesean detectar y marcar de color blanco para obtener la imagen binaria final.

Figura 2.10: Tipos de bordes descritos en una dimension

Una recomendacion para detectar mejor los bordes, es realizar un preprocesamiento a la imagen para reducirel ruido que pueda haber en la imagen y ası no detectar falsos bordes, para ello es recomendable filtrar laimagen para homogeneizarla, sin embargo, dependiendo del filtro puede que los bordes se suavicen dema-siado y sea mas dificil detectar los bordes debido al cambio suave en los valores de los pixeles de la imagenresultante [13, pp. 145-146].

Un filtro conveniente para este preprocesamiento es el filtro mediana, ya que toma cada punto de la imageny lo convierte en el valor de la mediana entre ese punto y sus vecinos adyacentes tanto veticales como dia-gonales, cuando el filtro es de 3 × 3. Lo conveniente de este filtro, es que los bordes no se suavizan tantocomo otros filtros, tal como ocurre con el filtro gaussiano o el filtro promedio manteniendo mucho mejor losdetalles de la imagen. [13, pp. 122-123].

2.3.1. Metodo LaplacianoEl filtro laplaciano es una matriz que se va desplazando a lo largo de la imagen y va obteniendo el equi-valente de la segunda derivada de la region que esta siendo filtrada [13, pp, 149-156], de este modo seconsidera como borde a todos los valores que sean cero en el resultado, ya que al sacar la segunda derivadade una funcion f(x, y) e igualarla a cero, se encuentran los puntos de inflexion de la funcion original, esdecir un borde de la imagen, tal como se muestra en la figura 2.11 tomada de [13, pp. 154] que en el casode utilizar un threshold, se aceptarıan como bordes los puntos que estan entre a y b de la imagen mencionada.

9

Figura 2.11: Modo en que actua el filtro laplaciano

En el caso del trabajo de grado, no se utiliza ningun threshold y se utiliza el filtro laplaciano por defectodescrito con la matriz de la ecuacion (2.5), segun las explicaciones de la biblioteca OpenCV utilizada parael desarrollo de dicho filtro con la herramienta de programacion Python [14], este operador es obtenido alresolver la segunda derivada mediante ecuaciones diferenciales [13, pp. 154-155] tomando un punto de laimagen (i, j) y hallando la segunda derivada de la matriz conformada por los valores adyacentes, formandouna matriz f de 3× 3 como la que se muestra en la solucion que lleva a la ecuacion (2.7), donde esta matrizf se opera con el operador∇2.

∇2 =

0 1 01 −4 10 1 0

(2.5)

Un segmento de la imagen completa se representa con la funcion f de la ecuacion (2.6) donde la posicion(i, j) de la matrız es un pixel de la imagen y los valores de alrededor corresponden a los pixeles adyacentes.Cada vez se toman valores diferentes de (i, j) hasta recorrer toda la imagen.

f =

[i− 1, j − 1] [i− 1, j] [i− 1, j + 1][i, j − 1] [i, j] [i, j + 1]

[i+ 1, j − 1] [i+ 1, j] [i+ 1, j + 1]

(2.6)

Esta matriz recorre cada pixel de la imagen y halla la segunda derivada de esa region y se encuentra de esemodo los bordes de la imagen, al operar la matriz con cada region de la imagen centrada en el pixel (i, j),la ecuacion que describe la solucion de la segunda derivada resulta siendo la de la ecuacion (2.7). Este filtrolaplaciano es ideal especialmente para detectar bordes tipo rampa [13, pp. 157], y este tipo de bordes son losmas frecuentes en imagenes comunes junto con bordes tipo techo. Los bordes tipo linea y paso se podrıanconsiderar practicamente bordes ideales, que son poco comunes en imagenes reales y mucho menos comu-nes al utilizar el filtro mediana implementado en el presente trabajo de grado.

10

∇2f =δf

δx2+δf

δy2

∇2f =

0 1 01 −4 10 1 0

[i− 1, j − 1] [i− 1, j] [i− 1, j + 1][i, j − 1] [i, j] [i, j + 1]

[i+ 1, j − 1] [i+ 1, j] [i+ 1, j + 1]

δf

δx2+δf

δy2= f [i, j + 1] + f [i, j − 1] + [i+ 1, j] + f [i− 1, j]− 4f [i, j] (2.7)

El resultado de esta operacion, se asigna a la matriz binaria resultante en la posicion del pixel (i, j) evalua-do [13, pp. 155-157], de este modo, si se obtiene un borde, se asigna el valor al pixel de 255 (blanco) y si noes un borde se le asigna un valor de 0 (negro).

2.3.2. Metodo de SobelEl operador Sobel actua bajo la misma teorıa del operador Laplaciano mencionado en la seccion 2.3.1, soloque esta vez no se obtiene la segunda derivada sino que se obtiene la primera derivada y se encuentran losvalores maximos y mınimos [13, pp. 147], marcandolos como bordes, tal como se observa en la figura 2.11en la representacion de f ′(x, y), donde el maximo de la grafica coincide con el borde de la imagen, estaprimera derivada corresponde con el gradiente de la matriz.

El operador utilizado para encontrar la derivada horizontal de la imagen corresponde a la matriz Sx de laecuacion (2.8), mientras que para hallar la derivada vertical se utiliza la matriz Sy tal como se aprecian acontinuacion [13, pp. 147]:

Sx =

−1 0 1−2 0 2−1 0 1

Sy =

1 2 10 0 0−1 −2 −1

(2.8)

Al operar estas matrices con f de la ecuacion (2.6) con cada uno de estos operadores Sx y Sy se obtienenlos bordes verticales Bx y horizontales By separadamente como se describe en las ecuaciones (2.9) y (2.10),por esta razon es necesario sumar los cuadrados de cada matriz resultante, obteniendo todos los bordes enla imagen final como lo hace el algoritmo utilizado en el presente trabajo de grado [15]. Se obtiene de estemodo una imagen binaria final donde los bordes se describen de color blanco y el resto de la imagen resultade color negro.

Bx(i, j) = Sxf (2.9)

By(i, j) = Syf (2.10)

2.3.3. Metodo de CannyComo el operador Sobel descrito en la seccion 2.3.2 se halla el gradiente a lo largo de la imagen, lo queequivaldrıa a hallar la primera derivada y de este modo se encuentran los maximos y mınimos valores delgradiente que corresponderıan a los posibles bordes de la imagen [13, pp. 169-173]. Ademas de hallar losmaximos y mınimos, se puede hallar la direccion en la que va el borde, y de ahı comienza a surgir la dife-rencia en este metodo de deteccion de bordes.

El algoritmo de Canny comienza con el filtrado de la imagen (preprocesamiento), luego se obtiene la mag-nitud del gradiente mediante la obtencion de las derivadas parciales en cada punto de la imagen, y se hallatambien la direccion (angulo) de la normal al borde detectado. Luego se eliminan los bordes ”no maximos 2

finalmente se utilizan dos thresholds para seleccionar los bordes y eliminando posibles falsos positivos [13,

11

pp. 172]. A continuacion se explica cada etapa con mayor detalle.

Teniendo las ecuaciones (2.9) y (2.9) donde Bx y By tienen la informacion de las derivadas parciales en x yy de la imagen, se encuentra la magnitud en cada punto de la imagen obteniendo B en la ecuacion (2.11) yse halla la direccion con la ecuacion (2.12) donde ahora α es una matriz de el angulo de la normal de cadaborde. Estos bordes se aproximan a 4 regiones (0, 1, 2 y 3), que se pueden observar en la figura 2.12 tomadade [13, pp. 171]. Estos angulos se tendran en cuenta para la etapa de los dos thresholds que se explican masadelante [13, pp. 171].

B =√Bx

2 +By2 (2.11)

α = tan−1(By

Bx

)(2.12)

Figura 2.12: Angulos detectados por Canny

La siguiente parte, la eliminacion de los bordes ”no maximos”, lo que hace es convertir el grosor los bordesdetectados en toda la imagen a unos bordes del grosor de un pixel, para ello, se recorre la imagen pixel porpixel de la matriz B de la ecuacion (2.11) y se comparan los valores con los pixeles vecinos, si hay un pixelvecino con un valor menor, se le asigna un valor de cero a ese pixel y se continuan revisando los demaspixeles de la imagen [13, pp. 170-171].

Ahora bien, teniendo estos bordes del grosor de un pixel, se vuelve a recorrer esta matriz binaria que contienelos bordes de la imagen y se asignan valores maximos (255) a los pixel cuya la magnitud sea mayor a unthreshold alto (Th) y se asigna un valor de cero a los pixeles con valores por debajo de un threshold bajo(Tl). Ahora bien, queda un rango pendiente para asignar y es el rango entre Tl y Th, los valores que tenganmagnitudes entre el nivel bajo y el nivel alto deben se deben verificar y confirmar que tengan una conexiondirecta o indirecta con un pixel que este por encima del valor Th, asegurando que ese posible borde tieneuna conexion con un borde que esta por encima del threshold alto y se asegura de esta manera que ese pixel,aunque este por debajo de Th es un borde por tener un camino hasta un pixel que es seguramente un bordeal estar por encima de Th [13, pp- 171-172].

Con esta explicacion se resumen los metodos de reconocimiento de bordes que se evaluaron en el presentetrabajo de grado y que para su mayor comprension se pueden consultar las referencias citadas. Ahora seexplicara el algoritmo de reconocimiento de forma utilizado que hace parte del proceso de segmentacionexplicado en la siguiente seccion.

12

2.4. SegmentacionSegmentacion se refiere dividir, seleccionar y marcar las secciones de interes de una imagen, al filtrar laimagen segun el color es parte de la segmentacion pues se selecciona en la imagen los colores de interes,luego al detectar los bordes de la imagen es otro proceso de segmentacion y se obtienen los bordes que eneste caso es la region de interes.

Ahora bien, para finalizar el proceso de segmentacion despues de haber detectado los bordes que hacen partea su vez de objetos del color deseado es necesario reconocer el centro de la esfera en caso de detectar queefectivamente los bordes detectados conforman una esfera. Para ello, se utiliza un algoritmo que utiliza latransformada de Hough que se describe a continuacion.

2.4.1. Algoritmo HoughCirclesHoughCircles es una funcion de la biblioteca OpenCV [16] y es un algoritmo que se divide en dos etapas;Primero utiliza el metodo de Canny descrito en la seccion 2.3.3 y utiliza la informacion del angulo del bordedetectado segun la figura 2.12 y a partir de ahı se determinan las lineas normales a la posible cırcunferenciade la imagen, ya que en un cırculo ideal, las lineas normales al borde deben intersectarse justo en el centrodel cırculo. Con esta informacion, en una imagen real, se puede determinar un radio aproximado del posiblecırculo detectado, encontrando el punto donde hay un mayor numero de intersecciones de estas lıneas lasnormales al borde. este metodo se conoce como 21HT [17] y es el que se utiliza en el algoritmo de OpenCVpara hallar cırculos (HoughCircles).

La segunda etapa es utilizar la transformada de Hough para cırculos [13, pp. 218-223], que consiste enutilizar las ecuaciones parametricas en coordenadas polares del cırculo descritas en las ecuaciones (2.13) y(2.14) y aplicar la transformada de Hough, que conciste en expresar estas ecuaciones pero en terminos de xcy yc que equivalen al posible centro del cırculo.

x = xc + r cos(θ) (2.13)

y = yc + r cos(θ) (2.14)

Al expresar las ecuaciones (2.13) y (2.14) en el espacio de hough se obtienen las ecuaciones (2.15) y (2.16)donde r y θ equivalen a los valores conocidos del radio y el angulo hallados en la primera etapa con ladeteccion de bordes y donde x y y son el pixel de la imagen perteneciente a un borde que se esta evaluando,de esta manera al recorrer los bordes de la imagen, se pueden obtener varios valores de xc, yc y r.

xc = x− r cos(θ) (2.15)

yc = y − r cos(θ) (2.16)

Para terminar se utiliza un acumulador que consiste en un sistema de votacion el cual considera cuantasveces existe el mismo centro y el mismo radio, distinguiendo que los mayores votos corresponden realmentea un cırculo, utilizando de este modo un threshold o dos, como lo hace Canny y como lo hace el algoritmo deHoughCircles de OpenCV utilizando el mismo metodo descrito en la seccion 2.3.3 con un threshold bajo yun threshold alto que segun el acumulador y los posibles centros detectados, se puede determinar los bordesque tienen mas posibilidades de pertenecer a un cırculo en la imagen.

2.5. Plataforma VEXLa plataforma VEX esta disenada para estudiantes que quieran explorar y adquirir conocimiento en el campode la robotica abarcando diferentes disciplinas tales como la ciencia, tecnologıa, ingenierıa y matematicas.Adicionalmente La robotica educativa de VEX pretende fomentar en los estudiantes el trabajo en equipo, el

13

liderazgo y el pensamiento analıtico a la hora de resolver un problema.

Esta plataforma esta conformada por controladores, actuadores, sensores, fuentes de alimentacion, comuni-cacion inalambrica, adaptadores y piezas mecanicas. En nuestro caso fue necesario emplear la mayorıa deestos componentes para poder disenar el robot de prueba.

Microcontrolador ARM Cortex: Es el cerebro de cada robot ensamblado con piezas VEX, el cual manejala informacion y la potencia del sistema. El microcontrolador ARM Cortex se puede programar medianteROBOTC que es un lenguaje de programacion basado en c, el cual cuenta con las bibliotecas y la herramientanecesaria para realizar las diferentes tareas que se quieren ejecutar con el robot de prueba. En la figura 2.13se puede observar este componente [3].

Figura 2.13: Microcontrolador ARM Cortex

Para el trabajo de grado se utilizo el microcontrolador ARM Cortex-M3 que cuenta con un procesador STmir-coelectronics ARM Cortez-M3, tecnologıa inalambrica VEXnet, 8 puertos de servomotores y 2 de motores,puerto I2C, 8 entradas analogicas, 12 puertos digitales In/Out . Todas las especificaciones del microcontro-lador se pueden consultar en la pagina oficial de VEX.

Figura 2.14: Diagrama de conexion Coxtex

Comunicacion inalambrica VEXnet:Para la comunicacion inalambrica del microcontrolador ARM cortex y los joystick VEXnet se utilizo elVEXnet key 2.0 que usa el protocolo de comunicacion VEXnet 2.0 sobre una radio frecuencia de 2.4GHz yun puerto USB [3].

Encoder de cuadratura:

14

La funcion de un encoder es convertir el movimiento mecanico en pulsos digitales que pueden ser interpre-tados por un controlador de movimiento. Este posee un engranaje interno especifico con un disco conectadoa el eje giratorio del motor, que esta impreso y se separa por cuadrantes de color negro y blanco. Como seaprecia en la figura 2.15.

Figura 2.15: Disco interno del encoder

A medida que el eje del motor rota, el sensor infrarrojo emite luz que es recibida por un sensor optico ge-nerado por pulsos digitales a medida que la luz pasa por el disco. Esto produce una secuencia que puede serusada para controlar el radio de giro y la direccion del movimiento.

El encoder que se utilizo para el trabajo de grado fue el modulo codificador integrado para el Motor 393 quese comunica a traves de I2C. Los motores 393 que se implementaron fueron configurados con la funcion develocidad lo que quiere decir que el encoder mide 392 pulsaciones por revolucion toda esta informacion seencuentra en la pagina oficial de VEX [3].

2.5.1. Robot movil diferencialUn Robot movil es una maquina automatica que tiene la capacidad desplazarse en diferentes direcciones,este dispositivo por lo general se mueve con patas o ruedas dependiendo de la aplicacion. Estos son utiliza-dos en la industria, en proyectos militares y aplicaciones domesticas.Existen diferentes tipos de robot movilen configuraciones cinematicas que dependen de la posicion de las ruedas y los movimientos que se quieranrealizar, las tareas que estos pueden desarrollar son esquivar obstaculos, definir trayectorias y recoger objetos.

El modelo de robot movil diferencial cuenta con cuatro o tres llantas, dos llantas delanteras de atraccionque tienen acoplados dos motores DC y una o dos llantas de apoyo traseras que mantienen la estabilidad delrobot. Esta configuracion se define unicamente por el movimiento que genera las ruedas de atraccion; en lafigura 2.16 se puede apreciar el modelo diferencial.

Figura 2.16: Modelo diferencial

En la figura1 2.16 tomada de [18] se puede observar la ubicacion que tiene el robot y el eje coordenado enx y y, ademas del angulo theta que define la orientacion del robot.Este modelo diferencial esta compuestopor un sistema mecanico que tiene restricciones cinematicas las cuales se tienen que tener en cuenta para eldesarrollo de los controladores.

Teniendo en cuenta el modelo de la figura 2.16 se pueden tener las ecuaciones cinematicas del sistema queson [19]:

15

S =

X(t)

Y (t)

θ(t)

=

cosθ 0senθ 0

0 1

[V (t)ω(t)

]=

V cosθV senθω(t)

(2.17)

2.5.2. Control on-offControlar un proceso consiste en mantener una variable controlada en la referencia a la que se quiere llegar.Existen muchos tipos de controladores entre los mas comunes estan el control PID y el control On-off [20].

El controlador on-off compuesto por una senal que se activa o se desactiva dependiendo del valor de la refe-rencia, el cual solo cuenta con dos posiciones ya sea encendido o apagado. Este control tiene un amplio usoen aplicaciones industriales sencillas y domesticas por su construccion [21].

La referencia por lo general tiene una variacion cada vez que se ejecuta el control, esto produce una histeresisque esta definida como la variacion en el tiempo de apagado o encendido del controlador, esto es debido a laconstruccion mecanica y el sensado de los motores ya que no son totalmente iguales.

Para explicar este controlador se utiliza un pulso u(t) que se considera como una variable manipulada quevaria dependiendo al error, cuando el error e > 0, u(t) esta en alto, donde su valor es maximo y cuandoe 6 0, u(t) esta en bajo donde su valor es mınimo. Esto se puede observar en la figura 2.17 tomada de [22],donde se describe el diagrama de bloques de un control on-off.

Figura 2.17: Control On-Off

2.6. Sensor KinectEl sensor Kinect de Microsoft fue disenado principalmente para la consola de videojuegos XBox, sin em-bargo han surgido muchas aplicaciones para este sensor y se han desarrollado proyectos aprovechando lacapacidad de adquirir imagenes de color y de profundidad [23], para elaborar mapas con la informacioncapturada, para hacer conferencias mas realistas e interactivas o incluso para realizar animaciones 3D [24] ymuchas otras aplicaciones.

Las caracterısticas principales del Hardware se pueden observar en la figura 2.18 tomada de [23], donde elsensor de color (Color Sensor), captura la imagen RGB como se describe en la ecuacion (2.2), mientras quepara la captura de la imagen de profundiad, se utiliza el emisor infrarrojo (IR Emitter) para emitir un patronde rayos infrarrojos y el sensor de profundidad (IR Depth Sensor) recibe el patron y calcula la distancia a laque esta cada pixel de la imagen.

16

Figura 2.18: Componentes principales del Sensor Kinect

El sensor es capaz de capturar 30 imagenes por segundo, es decir 30fps por sus siglas en ingles, tambientiene un arreglo de microfonos capaces de detectar en que direccion proviene el sonido, y tiene un motor(Tilt Motor), que sirve para inclinar verticalmente hacia arriba o hacia abajo el sensor Kinect [23]

Los angulos que alcanza a capturar el sensor Kinect tanto en la captura de la imagen de color como la imagende profundidad [23], se pueden observar en la figura 2.19.

Figura 2.19: Angulos que detecta el sensor Kinect

Cabe decir que en la vista lateral, el angulo de 43o puede aumentar ±27o con la ayuda del Tilt Motor [23].Sin embargo, en el presente trabajo de grado, se utilizara el angulo del motor en 0o, ya que en las condicionestrabajadas, no es necesario aumentar ese rango.

2.7. Tarjeta de desarrollo Raspberry PiEsta tarjeta de desarrollo es practicamente un computador al que se le puede instalar un sistema operativocomo Windows 10 IOT Core, o sistemas operativos de Linux como Snappy Ubuntu Core, Ubuntu Mate yotros sistema que se han desarrollado para este proposito [25]. En este trabajo de grado se utiliza el sistemaoperativo desarrollado oficialmente para Rasbperry Pi llamado Raspbian, el cual se desarrollo con base en elsistema de Linux Debian.

Hay varias versiones de esta tarjeta de desarrollo, la que se utilizo en el presente trabajo de grado es laRaspberry Pi 3 Model B, que se puede observar en la figura 2.20, tomada de [26].

Figura 2.20: Tarjeta de desarrollo Raspberry Pi 3 Model B

17

Esta tarjeta actualmente tiene la mayor velocidad de procesamiento en comparacion con las demas versiones,tiene una velocidad de 1,2GHz, una memoria RAM de 1GB, 4 puertos USB, 40 terminales de propositogeneral (GPIO) que se pueden observar en la figura 2.21 tomada de [27] que se utilizan para enviar la infor-macion a la plataforma VEX. Ademas cuenta con una salida HDMI para la visualizacion en una pantalla ycon una entrada de tarjeta micro SD que sirve para reemplazar el disco duro de un computador convencional.Todas estas especificaciones se pueden consultar en la pagina oficial de Raspberry Pi [26].

Figura 2.21: Diagrama de Pines GPIO de la Raspberry Pi 3 Model B

La eleccion de esta tarjeta de desarrollo, y del sistema operativo utilizado, se debio a la facilidad con la quese pueden utilizar hardwares externos a traves de puertos USB y a traves de terminales de proposito general(GPIO), ademas tiene la capacidad de utilizar las bibliotecas necesarias para el proyecto, que principalmenteson OpenCV [8], scikit-image [28] y libfreenect [29], que son librerıas compatibles con la herramienta deprogramacion Python para el procesamiento de imagenes y para el control del sensor Kinect. Estas librerıasson compatibles con este sistema operativo y se siguieron tutoriales muy bien desarrollados [30, 31].

18

3. OBJETIVO DEL PROYECTOA continuacion se presentara el cumplimiento de cada objetivo del trabajo de grado, exponiendo el estadofinal del proyecto.

3.1. Desempeno del proyecto ante los objetivos especıficosSe evaluaron y compararon tres algoritmos de procesamiento de imagenes para reconocer los bordes de lasesferas utilizadas como objetivos del robot. Se tuvieron en cuenta los resultados de los tiempos de duracionde los metodos Laplaciano, Canny y Sobel descritos en el marco teorico.

Con las pruebas realizadas se selecciono el metodo Laplaciano que tuvo un tiempo promedio de ejecucionde 19 ms en comparacion con los 29,1 ms y 226,3 ms de los metodos de Canny y Sobel respectivamente.

Se implementaron y compararon tres metodos de reconocimiento de color para filtrar y detectar las zonasnaranjas o verdes de la imagen. Se tuvieron en cuenta los tiempos de ejecucion de los filtros HSV, HSL yLab mencionados en el marco teorico para seleccionar el filtro mas eficiente y el que mejor se desempenoante los cambios de luz.

El algoritmo de Lab presento un tiempo de ejecucion de 119 ms y presento una menor variacion ante loscambios de intensidad lumınica, manteniendo un rendimiento constante a pesar de que fuera un dıa nubladoo muy soleado, los tiempos de HSV y HSL fueron de 132,9 ms y 142 ms respectivamente.

Con los datos adquiridos por la camara infrarroja del sensor Kinect, fue posible determinar la posicioncoordenada en la que estaban las esferas detectadas con el procesamiento de imagenes y se verificaron lasmedidas, obteniendo un error maximo de ±2,85 mm, con un error cuadratico medio de 0,905 % teniendoen cuenta que al utilizar un metro como instrumento de medida, se tiene un error de ±1 mm en la medicionde la distancia real del objetivo utilizado. De este modo se logro compar las medidas obtenidas por el sensorkinect y las medidas con el metro.

Se diseno y se ensamblo un robot con piezas VEX, con el fin de probar el sistema de vision artificial y se eje-cutaron rutinas especıficas, demostrando la recepcion serial de los datos enviados por la tarjeta de desarrolloRaspberry Pi a la plataforma VEX, la cual recibe la informacion coordenada de la ubicacion de la esferaencontrada y su respectivo color, de esta manera se controla el robot a traves del microcontrolador ARMCortex descrito en el marco teorico.

El robot de prueba es capaz de desplazarse hasta la pelota objetivo, y en caso de haber varias, va en la ma-yorıa de los casos primero por la de color naranja que tiene una prioridad mayor sobre las demas. El robotde prueba se programo para que al ejecutar el programa, recogiera cuatro pelotas, una naranja y tres verdes.De este modo se pudo probar que el sistema de vision artificial detecto correctamente los objetivos y enviolas coordenadas a la plataforma robotica para que fuera hasta el objetivo y recogiera la pelota.

Cumpliendo con todos estos objetivos especıficos del proyecto, se llego a la solucion general del problema,en el siguiente numeral se describe el estado final del trabajo de grado.

19

3.2. Solucion del problema definidoSe implementaron algoritmos de procesamiento de imagenes para reconocer la posicion y color de las pelo-tas verdes y naranjas de VEX evaluandolos con un robot de prueba.

En la figura 3.1 se puede apreciar el robot de prueba, con el sistema artificial integrado en su diseno. Sepuede observar el sensor Kinect que esta conectado a la tarjeta de desarrollo Raspberry Pi, la cual envıa demanera serial la informacion procesada al microcontrolador de VEX.

Figura 3.1: Robot de prueba

Despues de recibir los datos de las coordenadas del objetivo, el robot enciende el led correspondiente al colordetectado, luego gira hasta tener la pelota al frente y se desplaza hasta ella, y al llegar hasta el objetivo, seactiva el mecanismo de recoleccion del robot y atrapa la pelota, luego retorna a su posicion inicial y apagael led y espera a recibir la siguiente informacion del sistema de vision artificial.

20

4. DESARROLLOA continuacion se presentan los elementos utilizados para la realizacion del proyecto, se describe la tecno-logıa utilizada en cada parte del desarrollo y el modo en que se llego a las soluciones que satisfacen lasnecesidades del proyecto de grado.

El sistema general utilizado se puede ver representado en el diagrama de bloques de la figura 4.1, donde laRaspberry Pi adquiere las senales del kinect capturando una imagen de color y otra con la informacion deprofundidad, luego la procesa para segmentar la imagen y reconocer el objetivo mediante la imagen de color,luego se toma la posicion del pixel que esta en el centro del objetivo y se mide la posicion con la informacionde la imagen de profundidad. Con todo el procesamiento, se envıa la informacion serialmente a la plataformarobotica VEX, que controla el robot con el microcontrolador ARM Cortex de VEX.

Figura 4.1: Diagrama de bloques del trabajo de grado

4.1. Desarrollo del software en la Raspberry PiLo primero que se debe hacer para elaborar el sistema de vision artificial es poder adquirir las senales delsensor kinect, para ello se debe instalar la herramienta de programacion Python y la librerıa desarrollada porOpenKinect [29] para poderla usar con Linux, llamada libfreenect, instalandola en la Raspberry Pi [31].

Para el procesamiento de imagenes, se instala la librerıa OpenCV [8,30], que contiene las herramientas paraaplicar todo lo descrito en el marco teorico. Ahora bien, como se puede observar en el anexo A.1, las pri-meras doce lıneas de codigo, se importan las librerıas que se van a utilizar, la librerıa scikit-image [28] queesta entre las lıneas 7 y 12 del codigo, se utilizo para aplicar el metodo de Sobel en la deteccion de bordes,

21

de resto se utilizo OpenCV (cv2 en la lınea 5) y numpy en la lınea 4 [32] que es la librerıa que maneja losarreglos y matrices donde se almacenan las imagenes y los resultados procesados. La librerıa libfreenect seimporta en la lınea 3 como import freenect.

Despues de esto, se procede con la captura de las imagenes del sensor kinect, para ello se implementaronlas funciones frame RGB(): y frame depth(): en las lıneas 15 y 21, las cuales retornan las matrices de laimagen RGB y la imagen de profundidad [31]. La imagen de profundidad no se podrıa visualizar en unformato uint8, ya que cada pixel se representa con 11 bits, dando un rango decimal de 0 a 2048 [33], parapoderla visualizar se puede cambiar al tipo uint8 con la lınea 23, que esta comentada porque era una pruebade escritorio. Un ejemplo de las imagenes adquiridas se puede apreciar en la figura 4.2.

(a) Imagen de Profundidad en formato uint8 (b) Imagen RGB

Figura 4.2: Imagenes RGB y de profundidad depth adquiridas por el sensor Kinect

Ahora, la siguiente funcion filtLAB Verde(img) que esta en la lına 28 del codigo del anexo A.1 se encargade filtrar la imagen RGB capturada y obtener la imagen binaria donde solo lo blanco sea lo correspondienteal color verde. la siguiente funcion filtLAB Naranja(img) hace exactamente lo mismo pero con las regionesnaranjas, de este modo se obtienen dos imagenes binarias con las regiones verdes y naranjas que se analizanposteriormente para la deteccion de bordes y para hallar los cırculos.

4.1.1. Filtros de ColorCuando se filtran las imagenes, lo que se hace es escoger los valores equivalentes al color verde o naranja enlos diferentes espacios de color utilizados (HSV, HSL y Lab). Lo unico que hay que cambiar en el codigo enlas lıneas 29 y 58 del anexo A.1, es la parte en que se convierte COLOR BGR2EspacioDeColor, donde sereemplaza el EspacioDeColor por los espacios mencionados, teniendo en cuenta que OpenCV trabaja HSLcomo HLS, invirtiendo los canales L y S. Ahora para filtrar la imagen en cada espacio, se escogen los rangosde cada canal, encontrando un valor mınimo para cada canal de la imagen y un valor maximo. Para encontraresos rangos se puede hallar un histograma de unas imagenes de muestra y observar los posibles rangos denaranja y verde. El histograma muestra cuantos pixeles (bins) tienen determinado valor para cada canal.

Las imagenes de muestra para determinar los histogramas en cada espacio de color, fueron los siguientes(ver figura 4.3:

22

(a) Muestra1 color Na-ranja

(b) Muestra2 color Na-ranja

(c) Muestra3 color Na-ranja

(d) Muestra1 color Ver-de Claro

(e) Muestra2 color Ver-de Claro

(f) Muestra 3color VerdeClaro

(g) Muestra1 color Ver-de Oscuro

(h) Muestra2 color Ver-de Oscuro

(i) Muestra 3color VerdeOscuro

Figura 4.3: Muestras de color tomadas con el sensor Kinect

Para tomar estas muestras, se iluminaron de forma diferente a cada una, para poder tener en cuenta la varia-cion de brillo en las capturas, ya que los cambios de luz del entorno pueden afectar las imagenes capturadas.

Ahora bien, se hallaron los histogramas de cada una de estas imagenes y se realizo una tabla con los valoresmaximos y mınimos de cada canal. A continuacion se muestra un ejemplo de cuatro histogramas, dos parauna muestra verde en diferentes espacios de color y otros dos para una muestra naranja, luego de tener loshistogramas se pueden observar los rangos con los valores mınimos y maximos de cada canal en la tabla4.1. Valores hallados con los histogramas analizados hallando el mınimo entre las tres muestras y el maximoentre las tres muestras con cada canal, obteniendo los rangos de color deseados. Para obtener los histogramasse utilizo la librerıa matplotlib para Python [34].

El histograma de la figura 4.4a corresponde a la muestra de la figura 4.3a en el espacio de color Lab y el dela figura 4.4b equivale al de la muestra de la figura 4.3b en el espacio de color HSL.

(a) Histograma de la muestra 1 color Naranja (b) Histograma de la muestra 2 color Naranja

Figura 4.4: Histogramas de dos muestras de color naranja para determinar los rangos en los espacios de color

Para las muestras verdes, se puede observar el histograma de la figura 4.5a que corresponde a la muestra dela figura 4.3e en el espacio de color HSV y el de la figura 4.5b equivale al de la muestra de la figura 4.3g enel espacio de color Lab.

23

(a) Histograma de la muestra 2 color Verde Claro (b) Histograma de la muestra 1 color Verde Oscuro

Figura 4.5: Histogramas de dos muestras de color verde para determinar los rangos en los espacios de color

Ahora, la tabla obtenida con cada histograma de cada espacio de color esta en la tabla 4.1, donde se puedeobservar que la region con texto rojo, son los valores del histograma de la figura 4.4a y los valores de colornaranja son los de la figura 4.4b.

Tabla 4.1: Rango de maximos y mınimos para cada canal en cada espacio de color para las muestras naranjas

Rangos de Color NaranjaL 76 H 8 H 9a 168 S 253 S 2491-Lab maximob 166

1-HSV maximoV 126

1-HSL maximoL 70

L 20 H 1 H 1a 146 S 221 S 1951-Lab mınimob 139

1-HSV mınimoV 52

1-HSL mınimoL 27

L 152 H 14 H 15a 172 S 255 S 2552-Lab maximob 187

2-HSV maximoV 208

2-HSL maximoL 133


2-HSV mınimoV 70

2-HSL mınimoL 43

L 228 H 11 H 11a 183 S 241 S 2543-Lab maximob 194

3-HSV maximoV 255

3-HSL maximoL 200


3-HSV mınimoV 86

3-HSL mınimoL 51

L 228 H 14 H 15a 183 S 255 S 255Lab maximob 194

HSV maximoV 255

HSL maximoL 200

L 20 H 1 H 1a 136 S 163 S 144Lab mınimob 138

HSV mınimoV 52

HSL mınimoL 27

24

Realizando la misma tabla para las seis muestras verdes de la figura 4.3 y obteniendo los valores maximos ymınimos totales como los valores de color verde de la tabla 4.1, se obtienen los rangos definitivos de la tabla4.2 para filtrar las imagenes.

Tabla 4.2: Rangos utilizados en Python para los filtros en los diferentes espacios de color

Rangos del Color VerdeL 250 H 62 H 61a 136 S 255 S 253Lab maximob 179

HSV maximoV 255

HSL maximoL 152


HSV mınimoV 40

HSL mınimoL 20

Rangos del Color NaranjaL 228 H 14 H 15a 183 S 255 S 255Lab maximob 194

HSV maximoV 255

HSL maximoL 200


HSV mınimoV 52

HSL mınimoL 27

Luego de tener estos valores, se pueden utilizar para hacer los filtros de las imagenes capturadas, pero antesse deben transformar al espacio correspondiente como se muestra en las lıneas 29 y 58 del anexo A.1. Luego,se ingresan los valores mınimos en un arreglo y los maximos en otro, tal como esta en las lıneas 37 y 38 parael rango verde y en las lıneas 66 y 67 para el naranja. Luego de aplicar estos filtros, se almacena la imagenbinaria resultante, donde todos los pixeles que estan dentro de los rangos de la tabla 4.2 quedan de colorblanco, y el resto de color negro. Una imagen aplicando el filtro HSV se puede observar en la figura 4.6.Hay que tener en cuenta que las imagnes de muestra de la figura 4.3 y las que se muestran a continuacionse filtraron con un filtro mediana, lo que es conveniente para que las regiones se vuelvan mas homogeneasy al ser un filtro mediana no afecta tanto para la deteccion de bordes, ya que los bordes no los suavizatanto [13, pp. 122-123].

Figura 4.6: Izquierda imagen binaria filtrada en espacio HSV a la izquierda; Derecha Imagen RGB con filtro mediana

Como se puede observar, en la figura 4.6 no se tiene una segmentacion solida, quedan espacios en negrodentro de la region de interes, y hay regiones blancas en zonas que deben ser negras. Para solucionar esteproblema se puede aplicar la teorıa descrita en la seccion 2.2, realizando un opening, aplicando erosion yluego al resultado aplicando dilatacion. El resultado de eso se puede apreciar en la figura 4.7, donde solo seobtiene la region de interes, segmentando correctamente la imagen.

25

Figura 4.7: Izquierda imagen binaria filtrada y con opening a la izquierda; Derecha Imagen RGB original

La matriz utilizada para realizar la operacion de dilatacion, tiene una forma circular, ya que este operadormorfologico puede ayudar tambien a acentuar la forma de la region de interes, por eso se utilizo la matriz de7 × 7 que se puede observar entre las lıneas de codigo 73 y 79 del anexo A.1. Sin embargo para el procesoanterior de erosion, se utilizo una matriz cuadrada de 7× 7, como se puede apreciar en las lıneas de codigo42 y 71 del anexo mencionado.

4.1.2. Deteccion de bordes y reconocimiento de formaYa que se tiene la imagen filtrada, y despues de realizar lo mismo para el color naranja, se puede comenzara realizar la deteccion de bordes, para ello se utilizan los algoritmos de Sobel, Canny y Laplaciano descritosen el marco teorico. Cabe destacar que los threshold de Canny no son muy relevantes con la imagen binaria,ya que seguramente los cambios de nivel son muy drasticos, pues pasan de 0 a 255 inmediatamente, desdeahı ya se puede ver una desventaja de utilizar este algoritmo, ya que requiere mas procesamiento que losotros al utilizar un metodo mas complejo, luego se analizara el algoritmo mas rapido de los tres. Despues deutilizar la deteccion de bordes, se obtiene una imagen como la de la figura 4.8.

Figura 4.8: Borde detectado con el metodo de Canny

Ahora, para completar la etapa de segmentacion del sistema de vision artificial, se debe implementar el meto-do de Hough explicado en el marco teorico, para poder encontrar el centro de la esfera, para ello se utilizala funcion HoughCircles en las lıneas de codigo 131 y 133 del anexo A.1. Los parametros de esta funcionson la imagen de entrada que debe ser de escala de grises (o binaria en este caso), luego hay un parametropara seleccionar el metodo que actualmente solo hay uno y es el 21HT descrito en el marco teorico [16, 17],el siguiente parametro es el tamano o la resolucion de la matriz donde se almacena el acumulador, es decircuantos votos tiene cada posible pixel, si es 1 por ejemplo, es de la misma resolucion que la imagen deentrada, si es 2 es la mitad de la resolucion.

Los demas parametros son el de la mınima distancia que puede haber entre un cırculo encontrado y otro,mientras mas pequeno sea este valor es probable que se encuentren mas falsos positivos, y si es muy altopuede que no se detecten todos los cırculos, para ello se observo que con 60 pixeles de separacion, el sistemapodıa detectar dos pelotas a una distancia de 2 m, lo que hace que el radio sea mas pequeno que cuando estacerca [16].

Los parametros mas importantes son el parametro 1 que corresponde al nivel alto del threshold de canny, elnivel bajo es la mitad del alto por defecto. En el caso de este proyecto, podrıa tomarse un valor practicamentede 255, ya que los bordes tienen esa diferencia al ser binaria, sin embargo se dejo en un nivel de 60, aunque

26

no es muy relevante al ser una imagen en blanco y negro. El parametro 2 corresponde a la cantidad de votosde la transformada de Hough, que mientras mas votos es mas probable que sea el centro de un cırculo, paraencontrar este parametro se colocaron dos pelotas a 2 m del sensor y se puso un valor alto en el que no sedetectaba ningun cırculo, luego se fue disminuyendo hasta obtener el valor de 24 votos, cuando comenzo adetectar las dos pelotas que estaban a 2 m y detecta mucho mejor las que estan mas cerca de esa distancia. Poresta razon se determino que la distancia maxima detectable es de 2 m. Los ultimos parametros son el mınimoy maximo radio en pixeles que va a tener la pelota, sin embargo esto sirve solo cuando la pelota se detectaa la misma distancia, porque al variar la distancia respecto al sensor, el radio de la esfera en la imagen cambia.

En la figura 4.9 se puede observar el cırculo dibujado con el centro y el radio detectado por el metodo deHough, donde se puede observar que la identificacion de la pelota es efectiva.

Figura 4.9: Dibujo de la circunferencia con el radio y el centro encontrado con el metodo de Hough

4.1.3. Interpretacion de los valores de profundidad del sensor KinectHay que en cuenta que se va a tomar siempre el posible cırculo de la primera posicion del arreglo de cırculosque retorna la funcion de OpenCV, ya que es la que tiene mas votos [16]. Una vez encontrado el centro delcırculo se puede tomar el valor de la profundidad en ese pixel, sin embargo se puede observar un desfaceentre la imagen de profundidad y la imagen RGB, como se aprecia en la figura 4.10, pues al capturar unaimagen de profundidad, ubicando el objetivo en el centro de la imagen (punto naranja de la imagen de laizquierda), se observa que la captura de la imagen en RGB no coincide con el centro (punto azul en laimagen de la derecha).

Figura 4.10: Desalineacion entre la imagen RGB y Depth del sensor Kinect

Al tomar varias imagenes en distintas distancias y posiciones, se observo que la desalineacion es constante,por lo tanto, se prosiguio a encontrar el valor que se debe desplazar el centro de la esfera en RGB al centrode la esfera en la imagen de profundidad. Como resultado se obtuvo que el desfase es de 9 pixeles horizon-talmente y 9 pixeles verticalmente, teniendo en cuenta que la captura de las imagenes con una resolucionde 320 × 240, que es la resolucion utilizada en este proyecto para aumentar la velocidad de procesamiento,se puede obtener las imagenes de la figura 4.11, donde se concluye que al detectar un centro en RGB, se ledeben restar a sus coordenadas dentro de la imagen, 9 pixeles en cada eje.

27

Figura 4.11: Verificacion de la alineacion de la imagen RGB y la imagen de profundidad

Se puede observar que en la captura a 60 cm, hay un pequeno desfase que se puede deber a que la captu-ra RGB y la de profundidad no se hacen al mismo tiempo, y como se estaba moviendo el objeto mientrascapturaba las imagenes, puede que el tiempo entre cada captura haya generado ese desfase, sin embargo, engeneral se puede detectar el centro o un valor muy cercano y de este modo se puede obtener la informacionde la profundidad en la que esta ubicada la esfera.

Ahora sı se puede comenzar a trabajar con los valores de profundidad que se obtiene del sensor Kinect. Paracomprobar que los datos fueran coherentes, se tomaron varias muestras a varias profundidades de la cubiertade un cuaderno bastante liso y suficientemente rıgido, que se puede apreciar en la imagen que se mostroanteriormente en la figura 4.2. Se ubico con un metro la cubierta en varias distancias especıficas respecto alsensor y se tomaron los valores que entrega el kinect que varıan entre 0 y 2048 [33] para compararlos en latabla 4.3, teniendo en cuenta dos aproximaciones que hace OpenKinect para convertir esos datos a distanciaa partir de las ecuaciones (4.1) y (4.2). Se pueden comparar los datos reales con los teoricos en la tablamencionada.

δ =1

−3,07× 10−3 × valorKinect+ 3,33(4.1)

δ = 0,1236 tanvalorKinect

2842,5+ 1,1863 (4.2)

donde δ es la distancia en metros y la variable valorKinect es el valor que entrega el sensor Kinect. Enla tabla 4.3 se puede observar que los datos obtenidos con la ecuacion (4.2) (Metodo 1 OpenKinect) tieneun error cuadratico medio bastante grande, de 4,853 %, en comparacion con el otro metodo propuesto porOpenKinect (Metodo 2 OpenKinect) de la ecuacion (4.1) que tiene un error del 2,079 %, a partir de ahı sehizo una aproximacion propia, sabiendo la forma que tiene la ecuacion mencionada se puede encontrar unanueva ecuacion sabiendo que debe ser de la forma:

δ =1

B × valorKinect+ C

y a partir de esto, se pueden utilizar los valores reales de la tabla 4.3, resolviendo la ecuacion de la siguientemanera, hallando los valores de A y B:

28

δ = 2 valorKinect = 926

2 =1

B × 926 + C

δ = 1,3 valorKinect = 832

1,3 =1

B × 832 + C

Resolviendo el sistema de ecuaciones, se obtiene:

B = −2,8642× 10−3 C = 3,15221

(4.3)

Concluyendo con la ecuacion que disminuye el error a 0,905 % (ver Metodo Propio en la tabla 4.3):

δ =1

−2,867× 10−3 × valorKinect+ 3,1547(4.4)

(4.5)

En la figura 4.12 se puede observar graficamente la comparacion entre los metodos de la tabla 4.3 respecto alos datos reales (lınea azul). Se puede observar que el metodo propio (lınea roja) es la que mejor se adapta alos datos reales. Esta ecuacion se ve aplicada en la lınea 182 del codigo del anexo A.1

Figura 4.12: Comparacion de los datos de profundidad reales con los datos aproximados

29

Tabla 4.3: Comparacion de los valores obtenidos con medidas y con dos aproximaciones

Obtencion de datos AproximacionesSensor Depth

(valor) Distancia (m) Metodo 1OpenKinect (cm)

Metodo 2OpenKinect (cm)

MetodoPropio (cm)

519 0,6 0,6038 0,5758 0,6004569 0,65 0,6630 0,6316 0,6568604 0,7 0,7115 0,6776 0,7031637 0,75 0,7640 0,7276 0,7532663 0,8 0,8109 0,7724 0,7979689 0,85 0,8639 0,8232 0,8483712 0,9 0,9168 0,8740 0,8986733 0,95 0,9709 0,9262 0,9499751 1 1,0225 0,9762 0,9988768 1,05 1,0765 1,0286 1,0499783 1,1 1,1291 1,0797 1,0995796 1,15 1,1789 1,1283 1,1464810 1,2 1,2377 1,1858 1,2016821 1,25 1,2881 1,2353 1,2489832 1,3 1,3427 1,2891 1,3001841 1,35 1,3909 1,3367 1,3451851 1,4 1,4487 1,3939 1,3990860 1,45 1,5049 1,4497 1,4514868 1,5 1,5587 1,5032 1,5013874 1,55 1,6016 1,5460 1,5411881 1,6 1,6547 1,5992 1,5902888 1,65 1,7114 1,6561 1,6426893 1,7 1,7544 1,6993 1,6821900 1,75 1,8182 1,7637 1,7409906 1,8 1,8768 1,8229 1,7945909 1,85 1,9075 1,8540 1,8226914 1,9 1,9609 1,9083 1,8715921 1,95 2,0410 1,9899 1,9445926 2 2,1022 2,0526 2,0002

0,04853 0,02079 0,00905Error cuadratico medio (ECM): 4,853 % 2,079 % 0,905 %

Una vez se tiene el valor de la profundidad, se puede visualizar en una prueba de escritorio, como se de-termina efectivamente la distancia del objeto reconocido con el metodo de Hough. Se puede apreciar en lafigura 4.13

30

Figura 4.13: Deteccion de los objetivos con su respectiva distancia

Ya teniendo esto, se pueden calcular las coordenadas (x, y) utilizando trigonometrıa basica y conociendo laresolucion de la imagen que es de (320 × 240). Lo primero que hay que saber es que el agngulo maximohorizontal es de 57o y por lo tanto, se puede saber que cada pixel varıa 57o/320 px = 0,1781 o/px, yverticalmente 43o/240 px = 0,17916 o/px. Esto se ve aplicado en la lıneas de codigo 194 y 200 del anexoA.1. Teniendo el centro de la esfera en determinado pixel, se puede determinar el angulo vertical y horizontalrespecto al centro de la imagen, y ası determinar la posicion coordenada (x, y). Para entenderlo mejor sepuede observar graficamente en la figura 4.14.

(a) Vista en Perspectiva (b) Vista superior

Figura 4.14: Explicacion de la geometrıa para hallar las coordenadas de los objetivos

Sabiendo la posicion (a, b) del pixel resaltado en rojo de la figura 4.14a, se pueden calcular ambos angulosα y β como se observa en la ecuacion (4.6), teniendo en cuenta que (ao, bo) es equivalente a la mitad de laresolucion de la imagen (320 × 240), por lo tanto (ao = 160, bo = 120). Tal como se puede apreciar en lalınea de codigo 147 y 148 del anexo A.1, donde ese centro de la imagen equivalen a α = 0 y β = 0.

β = |bo − b| × 0,17916 o/px α = (ao − a)× 0,1781 o/px (4.6)

31

Con estos valores, ya se pueden determinar las coordenadas (x, y) con las ecuaciones (4.7) y (4.8), obtenien-do en metros la posicion del objetivo:

d = δ cosβ

x = d sin (α) [m] (4.7)

y = d cos (α) [m] (4.8)

Siendo δ la informacion de la distancia hallada con la ecuacion 4.4.De esta manera se concluye el desarrollo del sistema de vision artificial, para terminar y evaluar su eficiencia,se deben comparar los tres algoritmos de deteccion de bordes y los tres filtros de color utilizados para selec-cionar el mas rapido. Finalmente se desarrollo la transmision serial de estas coordenadas y la informacionde si la pelota es verde o naranja, es decir, si detecto una esfera en la imagen binaria con la region naranja oen la otra imagen binaria con la region verde; en el caso de haber detectado un objetivo naranja, solo enviaraesa informacion y no la informacion de las coordenadas de los objetivos verdes, dando ası la prioridad a laesfera naranja.

4.2. Desarrollo del software en el microcontrolador ARM Cortex de VEXLo primero que se debe hacer para elaborar el controlador del robot de prueba es instalar en el computadorla herramienta de programacion ROBOTC para VEX que esta disenada para poder enviar y recibir los co-mandos necesarios.

Una vez instalada esta herramienta es necesario instalar el driver VEXnet Serial USB, para poder tener co-municacion entre el microcontrolador cortex de VEX y el computador. Luego de esto se debe actualizar losdrives del Cortex de VEX para que se pueda transmitir y recibir los datos.

Ahora bien como se observa en el anexo A.3, en las primeras 11 lıneas se declaran entradas y las salidas delsistema, donde se tienen 4 entradas que son: 2 que se encargan de recibir los datos que vienen de la tarjetade desarrollo Raspberry Pi 3 model B llamados serial y ListoRasp,y 2 que son los sensores de los encodersde cuadratura. Las 6 salidas son: 1 salida digital que es ListoVex que envıa informacion para poderse comu-nicar con la tarjeta de desarrollo, 2 salidas digitales que se encargan de indicar el color de la pelota que hadetectado y 3 salidas que son los motores 393.

4.2.1. Control on-off de distancia:Se realiza caracterizacion de los motores derecha e izquierda para poder ver en que nivel se puede disenarel controlador on-off de avance y retroceso. Para esto se tomaron 24 datos por cada motor que van desde elnivel -127 hasta 127 en intervalos de 10, tal como se aprecia en la figura A.1 en el anexo A.4. Se procede ahacer el codigo que esta en el anexo mencionado, el cual se encarga de enviar un pulso con un tiempo de 3segundos para cada nivel, en este tiempo se midio cuantos ticks/revolucion giraba el motor.

Los motores izquierda y derecha fueron configurados en alta velocidad donde 1 vuelta son 392 ticks/re-volucion a una velocidad de 160rpm .Esta informacion se encuentra en la pagina de especificaciones delmotor393 [35].

En la siguiente grafica de la figura 4.15 se puede apreciar la caracterizacion de los dos motores en losdiferentes niveles.

32

Figura 4.15: Caracterizacion de los dos motores

Al observar la grafica se puede apreciar que la parte lineal para los dos motores esta dentro del rango de20 a 50 .Lo que quiere decir que dentro de esta region se puede disenar el controlador que se requiere. Seselecciono el nivel 40 para realizar en control on-off de distancia. Ahora bien teniendo en cuenta las llantasque se utilizaron para el robot de prueba que son ruedas VEX 2,75”[2], el cual tienen un diametro de 2,75”que en centimetros es 6.875 cm, con un perımetro de 21,59 cm. Teniendo en cuenta estos datos se realizauna conversion para saber exactamente cuantos ticks/revolucion deben girar los motores dependiendo de ladistancia que se quiere recorrer, para esto se utiliza la ecuacion (4.9):

vueltas = 393 [ticks/revolucion]× distancia [cm]

perimetro [cm](4.9)

Luego de tener este valor, se sensan los motores de ambos motores y con estos datos se crea un ciclo quemientras vueltas sea menor que el valor del sensado los motores giren hasta que se cumpla esta condicionesto se puede apreciar en las lıneas 83 a 87 del anexo A.3. Este Control hace que el robot vaya hasta ladistancia en centımetros que ha enviado la tarjeta de desarrollo Raspberry Pi 3.

4.2.2. Control on-off de giro:Para disenar este controlador se utilizo la tecnica Point turn que se basa en que gire el robot en sus propioeje, donde una rueda gira hacia adelante y la otra gira hacia atras, de tal manera en se mueven las ruedas endirecciones opuestas y esto logra que el robot gire. Este giro es bastante util para nuestra aplicacion y soloes valida para un robot diferencial. En la figura 4.16 tomada de [36] podemos observar la tecnica utilizada.

Figura 4.16: Tecnica de giro

33

Utilizando esta tecnica se sensa de manera experimental cuantos ticks/revolucion son 90 grados tanto parael giro del lado derecho como para el giro del lado izquierdo. Tomando 5 datos de cada sensado el promediode un giro de 90 grados fue de 1738 ticks-resolucion, con este dato se realiza la ecuacion (4.10):

ticks =1738× grados

90(4.10)

Esta ecuacion se encarga de convertir grados en ticks/revolucion, y se puede decir que esta tecnica es bastantelineal para realizar esta aproximacion [37].

Luego de tener este valor, se sensan los encoders de ambos motores y con estos datos se crea un ciclo quemientras ticks sea menor que el valor del sensado los motores giren uno hacia adelante y el otro hacia atrashasta que se cumpla esta condicion, esto se puede apreciar en las lıneas 37 a 44 del anexo A.3.

4.3. Comunicacion serial entre Raspberry Pi y ARM Cortex de VEXLo primero que se debe definir para el envıo de la informacion, es disenar la trama de datos que se va aenviar, para ello, se decidio enviar la informacion de color mediante dos bits, donde [0, 0] significa que no hadetectado ningun color, [0, 1] significa que detecto una pelota verde y [1, 0] significa que detecto una pelotanaranja. Para el envıo de las coordenadas, se decidio enviar cada una en un arreglo de 8 bits, dando un totalde 16 bits de coordenadas y dos bits de la informacion de color.

La trama se puede observar en la figura 4.17, donde estan los 18 bits distribuidos en el modo que se van aenviar al microcontrolador de VEX.

Figura 4.17: Trama de datos para enviar en transmision serial

Ahora bien, ya se definio el modo en que se va a representar el color, pero para expresar las coordenadas(x, y)dentro de la trama, es necesario dividir los valores maximos en x y en y en valores discretos. Para esose tomara como medida maxima respecto al sensor Kinect un valor de 2m, tal como se explica en la seccion4.1.3. Teniendo este valor y basandose en la figura 4.14 se pueden obtener los valores maximos de x y de y,tal como se muestra en las ecuaciones (4.11) y (4.12), teniendo en cuenta que el angulo horizontal maximoes de α = 57o y para obtener los maximos toca utilizar el angulo vertical como β = 0o.

x = 2 [m] sin 57o y = 2 [m]cos0o

x = 1,677 m (4.11)

y = 2 m (4.12)

Estos valores se pueden ver implementados en el codigo de transmision serial en las lıneas 22 y 28 del anexoA.2. Ahora es necesario dividir estos valores maximos entre los posibles valores que otorgan los bits paratransmitir. Debido a que la coordenada x puede tomar valores negativos, se utilizara el bit x1 de la figura 4.17para determinar si es un valor negativo o no, por lo tanto quedan 7 bits restantes desde x2 hasta x8, entreesos bits puede utilizarce un valor decimal entre 0 y 127, por esta razon se puede dividir el valor obtenidode la ecuacion 4.11 entre los 127. Y ası se puede convertir de decimal a binario el valor de la coordenada x.En cuanto a la coordenada y que es siempre positiva, se pueden utilizar los 8 bits, pudiendo dividir los 2mobtenidos de la ecuacion (4.12) entre el valor decimal maximo que tiene de capacidad los 8 bits (255). Conesto, se dividen los valores maximos en el valor mınimo de cambio discreto de cada coordenada.

34

De este modo, para convertir la coordenada de decimal a un valor entero que se pueda almacenar en los bits,se hace lo siguiente:

numx =127x

1,677

numy =255y

2

x1 =

{1, si numx 6 0

0, si numx > 0

Donde numx y numy son los valores que varıan entre 0 y 127 para la coordenada x y entre 0 y 255 para lacoordenada en y, mientras que x y y son los valores detectados por el sensor en metros, con variaciones entre0m y 2m. De este modo, los valores que se le asignan a los bits de x2 hasta x8 es el equivalente en binariode |numx|, en valor absoluto para el caso en que sea negativo, y se le asigna a x1, 1 o 0 dependiendo de si esuna coordenada en x negativa o positiva respectivamente; en el caso de los valores de y1 hasta y8, se asignael valor en binario de lo que se obtenga de numy.

Luego de tener la trama construida, se procede a realizar el envıo de la trama, para ello, se utilizaron trescables de comunicacion entre la Raspberry Pi y el microcontrolador ARM Cortex de VEX, uno llamadoListoVex, otro ListoRasp y otro llamado S que es el que envıa la trama serial; las dos primeras senalesmencionadas se encargan de controlar la comunicacion, y la tercera de enviar serialmente la informacion.Para entender como es el modo de comunicacion se puede observar la figura 4.18, en dode se observan estassenales y como se envıa dato por dato de la trama desde la Raspberry a la plataforma VEX.

Figura 4.18: Senales de comunicacion entre la Raspberry Pi y el microcontrolador VEX

Hay que tener en cuenta que a modo de proteccion, en el caso de que se corte la transmision antes de enviartoda la trama, la Raspberry Pi espera 10 segundos para volver a iniciar el algoritmo completo. Esto se puedever en la lınea de codigo 77 del anexo A.2, donde se sale del while en caso de que el tiempo transcurrido seamayor a los 10 segundos.

Por otro lado, se puede observar que despues de recibir la trama el microcontrolador de VEX, este lo vuelvea transformar a valores de distancia, en este caso lo convierte a centımetros en las lıneas de codigo 197 y 198

35

del codigo del anexo A.3. De este modo se concluye la transmision y recepcion de las coordenadas.

4.4. Arquitectura del robotEl robot de prueba se ensamblo con piezas VEX siguiendo un modelo de robot movil diferencial descrito enla seccion 2.5.1 que cuenta con dos llantas delanteras que son de traccion que tienen en su eje un motor 393VEX en configuracion de alta velocidad, y en la parte de atras tiene dos llantas que son de soporte para queel robot mantenga su centro de masa.

Para el chasis del robot se utilizaron cuatro C-canal de vex y dos angulos acopladores VEX, esto fue en-samblado siguiendo las especificaciones de robot pequeno para una competencia VEX. en la siguiente figura4.19 se puede apreciar la estructura realizada.

Figura 4.19: Arquitectura del robot

Ahora bien teniendo la estructura se procese hacer una especie de nivel en la barra del medio para que sepueda poner el kinect que es la vision del robot de prueba y en la parte inferior de este se colocan la tarjetade desarrollo Raspberry PI3 y el microcontrolador Cortex de VEX. en la figura 3.1 se puede apreciar esteensamble.

Luego se hace un mecanismo tipo catapulta en la parte frontal de tal manera que cuando el robot llegue hastala esfera la pueda recoger. Para este sistema se utilizo un motor393 que acciona el mecanismo cada vez queel programa se lo indique. Este mecanismo se puede apreciar en la figura 4.20.

Figura 4.20: Arquitectura del robot

36

Luego de esto se procede a utilizar 3 baterıas de NIMH de VEX a 3000m A y 7.2 V , donde una es paraalimentar el microcontrolador Cortex de VEX y las otras dos son para alimentar el kinect.

El kinect se debe alimentar con 12 V [29] entonces con las dos baterıas que se tiene se ponen de maneraserial y se obtiene 14.4 V, con este voltaje debemos utilizar un regulador para enviar solamente los 12 vque se necesitan para esto se implemento el siguiente circuito de la figura 4.21 que esta compuesto por unregulador lm 7812 de 12 voltios y los condensadores que son especificados por el datasheet del componente.

Figura 4.21: Regulacion de 12 V para el sensor Kinect

37

5. PROTOCOLO DE PRUEBASPara evaluar el sistema de vision artificial, se realizaran dos pruebas, la primera es medir el tiempo de proce-samiento de cada algoritmo, que segun los objetivos del trabajo de grado, se deben seleccionar los algoritmosmas rapidos. La segunda prueba es realizar con varias figuras de varios colores y varias formas, para verifi-car la correcta deteccion de objetivos del sistema, detectando falsos positivos, falsos negativos, verdaderospositivos o verdaderos negativos.

Prueba 1:Para evaluar la velocidad, se ejecutara el sistema de vision artificial, y se medira el tiempo que tarda en filtrarel color de la imagen y el tiempo en que detecta los bordes, para utilizar cada uno de los algoritmos, se rea-lizaran tres codigos, el primero ejecutara el filtro HSV de color y la deteccion de bordes mediante Laplace,el segundo utilizara HSL y Canny y el tercero Lab y Sobel. Luego, se mediran los tiempos de ejecucion deestos algoritmos con el comando time de python y se realizara una tabla de los tiempos obtenidos, tomandola duracion de ejecucion de estos algoritmos en 75 imagenes o cuadros (frames). Es importante que paratomar cada muestra, se debe realizar en el mismo ambiente, para ello se colocaran dos objetivos, uno verdey uno naranja en frente del sensor Kinect a una distancia de 60 cm tal como se muestra en la figura 5.1.

Figura 5.1: Prueba para medicion del tiempo de ejecucion de algoritmos

Prueba 2:En cuanto a la verificacion de la deteccion de los objetivos, se hara lo siguiente:1. Elaborar 12 figuras que no debe detectar el sistema, pero algunas de ellas deben tener colores detectablespor los filtros de color (ver figura 5.2) y utilizar tres pelotas (una verde claro, otra verde oscuro y otra naran-ja), que sı debe detectar el sistema, teniendo un total de 15 muestras de prueba.

2. A una distancia 1,5 m y con un angulo de 0o, ubicar las 15 muestras de prueba y capturar las imagenesejecutando el algoritmo de reconocimiento para verificar si cada imagen fue detectada como objetivo o no.

3. Realizar lo mismo del punto 2, pero con distancias de 1,5 m a 20o, 1 m a 10o, 60 cm a −10o, 2 m a 0o.teiendo un total de 75 capturas.

4. Registrar en tablas los resultados obtenidos para cada algoritmo (HSV - Laplace, HSL - Canny y Lab -Sobel), determinando con cada captura si se obtuvo un falso positivo, falso negativo, verdadero positivo overdadero negativo.

5. Analizar los resultados.

38

Figura 5.2: Muestras para evaluar el sistema de vision artificial

Prueba 3:Para evaluar la efectividad del proyecto de grado, se procede a realizar la evaluacion del robot de pruebapara ello, se hicieron cinco pruebas con el robot de prueba en el que debıa recoger cuatro pelotas (dos verdeoscuro, una verde claro y una naranja). el diseno de la prueba es el siguiente:

1. Colocar las cuatro pelotas en orden aleatorio a una distancia dentro de un rango 1 de 60cm a 1m respectoal robot y correr el programa de RobotC para poner en marcha el robot.

2. Verificar que la pelota naranja sea la que recoge primero el robot y anotar cuantas pelotas recoge, en casode fallar en alguna, se debe retirar la pelota que intento recoger o en caso de incertidumbre, se debe retiraruna pelota. Anotar las observaciones pertinentes. Realizar el procedimiento 1. y 2. cuatro veces.3. Repetir los puntos anteriores pero ahora sustituyendo la ubicacion en el rango 1 por la ubicacion de laspelotas en un rango 2 de 1m a 1,5m respecto al robot, y finalmente ubicarlas en un rango 3 de 1,5m a 2m.Esta prueba se puede observar graficamente en la figura 5.3, en donde se aprecia el orden 4123 de las pelotasrespecto al robot.

39

Figura 5.3: Ejemplo de la prueba 3 para evaluar el sistema de vision artificial

Como se puede observar, 1 es Naranja, 2 y 3 son Verde oscuro y 4 es verde claro. Las tablas adquiridas sepueden observar en las figuras A.5, A.6, A.7, A.8 y A.9, en el anexo A.6.

40

6. ANALISIS DE RESULTADOS6.1. Resultados de la evaluacion del sistema de vision artificialLos resultados obtenidos de la primera prueba explicada en la seccion 5, se obtienen las velocidades de cadaalgoritmo con cada frame capturado, la velocidad de los tres algoritmos de deteccion de bordes se puedenobservar y comparar en la figura 6.1.

(a) Resultados del metodo de Sobel (b) Resultados del metodo de Canny

(c) Resultados del metodo Laplaciano

Figura 6.1: Comparacion entre los tres algoritmos de deteccion de bordes

Como se aprecia en las graficas anteriores, el algoritmo con menor tiempo de ejecucion promedio es el meto-do Laplaciano con un tiempo de ejecucion de tan solo 19ms. Por esta razon, para cumplir con el objetivopresentado en la introduccion, para implementar el algoritmo mas eficiente, se debe seleccionar este metodode deteccion de bordes.

Por otro lado, la comparacion de los tres algoritmos de filtros de color, se pueden observar y comparar en lafigura 6.2.

41

(a) Resultados del filtro HSL (b) Resultados del filtro HSV

(c) Resultados del filtro Lab

Figura 6.2: Comparacion entre los tres filtros de color

Como se puede observar en las tres graficas anteriores, los algoritmos HSL y HSV, son lo que menor rendi-miento tienen, por esta razon, para cumplir con el objetivo de seleccionar el mas, se selecciona el filtro Labya que su tiempo de ejecucion es el menor, de este modo, se seleccionara la combinacion de algoritmos delfiltro Laplaciano para la deteccion de bordes y el filtro Lab para la deteccion de color. Sin embargo, hacefalta evaluar la efectividad de su rendimiento en la deteccion. Esta evaluacion se hara mas adelante.

Para comparar el rendimiento total de los algoritmos, se puede observar en la grafica de la figura 6.3 lasdiferentes combinaciones utilizadas; Laplaciano-HSV, Sobel-Lab, Canny-HSL y finalmente la seleccionadaLaplaciano-Lab. Los tiempos que se muestran corresponden a todo el sistema de vision artificial, incluyendoel metodo de Hough.

42

Figura 6.3: Tiempos de ejecucion de todo el sistema de vision, usando los algorimtos de deteccion de bordes y deteccion de color.

Como se puede apreciar, el sistema utilizado tuvo una eficiencia con bastante ventaja sobre los otros algo-ritmos, logrando seleccionar el algoritmo mas rapido de los estudiados en este trabajo de grado, ası mismo,se puede apreciar en la figura 6.4 los tiempos de cada parte del algoritmo final, en el que se utiliza metodoLaplaciano y Lab.

Figura 6.4: Tiempos del filtro Lab y de la deteccion de bordes con metodo Laplaciano

De esta manera se concluye la seleccion del sistema de vision artificial y se procede a evaluar la capaci-dad de reconocimiento mediante pruebas de Caracterısticas Operativas del Receptor (ROC por sus siglas eningles) [38]. Estas pruebas sirven para evaluar la eficacia del sistema de vision artificial. Esteas pruebas se

43

haran sobre los tres algoritmos (Laplace - HSV, Canny - HSL y Sobel - Lab). Esta evaluacion diagnosticaespecialmente el desempeno de los filtros de color, y es por eso que no se evaluo con el algoritmo final queya contiene Lab.

Pruebas ROC:Primero se debe saber que los Falsos Positivos (F.P.) son resultados que no debıa detectar pero por fallo delsistema lo detecto como objetivo. Los Verdaderos Positivos (V.P.) es cuando el sistema detecta el eobjetivoque efectivamente debıa encontrar. Un Verdaderos Positivos (V.N.) son las muestras que no son objetivos yefectivamente el sistema no las localiza. Y finalmente los Falsos Negativos (F.N.) son todas esas muestrasque sı debe detectar, pero el sistema falla y no las reconoce.

Teniendo en cuenta estos cuatro aspectos de evaluacion del sistema, se procede a colocar las muestras dela figura 5.2, pasando cada muestra en las ubicaciones mencionadas, pasando esas 15 muestras 5 veces yrevisando si detecto o no detecto la muestra. En general, el sistema completamente ideal se puede apreciaren la tabla 6.1

Tabla 6.1: Resultado ideal de una prueba ROC

15(V.P.)

0(F.P.)

0(F.N.)

60(V.N.)

Con esto, se obtienen las tablas de cada uno de los algoritmos utilizados, para Sobel - Lab, Laplace - HSV ypara Canny HSL se obtiene la tabla 6.2:

15(V.P.)

23(F.P.)

0(F.N.)

37(V.N.)

(a) Resultados Sobel - Lab

15(V.P.)

33(F.P.)

0(F.N.)

27(V.N.)

(b) Resultados Laplace - HSV

8(V.P.)

6(F.P.)

7(F.N.)

54(V.N.)

(c) Resultados Canny - HSL

Tabla 6.2: Tablas de resultados de las pruebas ROC

Observando la tabla 6.2c, ya se puede descartar el algoritmo inmediatamente, ya que de los 15 verdaderospositivos que debıa detectar, unicamente detecto 8, que es casi la mitad de las muestras.

Por el otro lado, se puede comparar entre las tablas 6.2b y 6.2a, para observar que el algoritmo de HSV tienemayor cantidad de falsos positivos, mientras que el algoritmo con Lab, tiene menos errores. Sin embargo,el sistema tiene un 43.3 % de error. A pesar de esto, se debe tener en cuenta que estas pruebas son muyexigentes para el sistema y es necesario probar el sistema de vision artificial con el robot de prueba, ademases posible que con el algoritmo final Laplace - Lab, el resultado sea mucho mas confiable.

Ahora bien, se puede observar graficamente estos resultados, sabiendo que la Razon de Verdaderos Positivos(TPR) y la Razon de Falsos positivos (FPR o la tambien llamada 1-especificidad) son [38]:

TPR =V.P.

V.P.+ F.N.

FPR =F.P.

F.P.+ V.N.

44

Las figuras obtenidas de los tres casos, se pueden observar a continuacion:

(a) Diagnostico de Sobel - Lab (b) Diagnostico de Laplace - HSV

(c) Diagnostico de Canny - HSL

Figura 6.5: Comparacion entre las tres curvas ROC

Mientras la curva tenga el punto mas cercano al eje de la razon de verdaderos positivos, significa que elsistema es mas confiable. Ademas el area bajo las curvas de estas graficas, puede indicar que tan bueno es elsistema, de este modo si el area bajo la curva da en un rango de 0.9 y 1, significa que es excelente, entre 0.8y 0.9, es bueno, entre 0.7 y 0.8 es justo, entre 0.6 y 0.7 es pobre y por debajo de eso es fallo.

Las areas bajo la curva son: para Sobel - Lab es 0.74, para Laplace - HSV es de 0.63 y para Canny - HSL esde 0.64. De este modo, se aprecia que Sobel - Lab esta en un rango justo, mentras que los otros dos estan enun rango pobre, de este modo se sabe que el sistema Sobel - Lab tiene mejor desempeno.

Por otro lado, la exactitud que se calcula como V.P.+V.N.Total de muestras , se obtiene que para Sobel - Lab es de 0.69,

para Laplace - HSV es de 0.56 y para Canny - HSL es de 0.83. A pesar de que canny tiene el valor ma-yor de exactitud, se selecciona Lab debido a que a pesar de que Canny - HSL detectara muchos verdaderosnegativos lo que hizo que aumentara su exactitud, no detecto bastantes verdaderos positivos, por lo que seselecciona Sobel - Lab como el que tiene mayor desempeno, que aunque no es tan exacto, es mas preciso ytiene mas probabilidad de detectar los verdaderos positivos que Canny - HSL, por tener una mayor razon deverdaderos positivos (ver figuras 6.5c y 6.5a).

En vez de realizar la evaluacion para el sistema final seleccionado, se procede a evaluar con el robot deprueba en la siguiente seccion.

45

6.2. Evaluacion del robot de pruebaAl realizar las pruebas descritas en la seccion 5, se registraron las tablas que se aprecian en el anexo A.6. Elpromedio de recoleccion de las pelotas fue de 42,4/48 por cada prueba, y en total sumando todas las pruebas,fue capaz de recolectar 212/240, por lo tanto su desempeno fue del 88,33 %, siendo capaz de recoger unagran cantidad de objetivos, gracias al sistema de vision artificial.

Las causas de los fallos fueron de debido a falsos positivos en un 2,92 %. Debido a obstaculizacion del ro-bot ya sea en su recorrido o en impedir que el sistema de recoleccion se moviera adecuadamente fue de un3,75 %; debido a problemas mecanicos y de control del robot ocurrio un 2,08 % y finalmente los fallos de noretirar las pelotas al tiempo cuando el robot ya la suelta, o cuando el robot intento recoger 2 pelotas al mismopor ponerlas tan cerca una de otra, o porque se desconecto o descargo la baterıa del microcontrolador o porno ser la pelota completamente naranja al tener un letrero negro, se tiene el resto del porcentaje de error de(2,92 %).

la suma total de estos errores es de 11,67 %, lo que indica que por cada 10 pelotas atrapadas pierde unaaproximadamente. Hay que tener en cuenta que l mayor error fue debido al entorno en el que se trabajo puesestaba muy obstaculizado, ya que el el espacio era pequeno, habıa varias personas en movimiento y variassillas.Ademas, se puede decir que el porcentaje de falsos positivos se debe directamente al desempeno del sistemade vision artificial, por lo que no solo se evalua el robot de prueba sino el sistema completo.En la figura 6.6a se puede observar una parte de la ejecucion de una prueba, cuando recoge la primera pelotanaranja. No se alcanza a visualizar, pero hay una pelota verde al lado derecho por fuera de las imagenes.

(a) Ejemplo de ejecucion de la evaluacion de prueba

46

7. CONCLUSIONES Y RECOMENDACIONES7.1. ConclusionesPara elegir los algoritmos del sistema de vision artificial se tuvieron en cuenta las velocidades de ejecucion,obteniendo un tiempo promedio de para el filtro de color Lab menor a los tiempos de los filtros de HSV yHSL; para los algoritmos de deteccion de bordes se concluyo que el metodo Laplaciano es el mas eficiente,comparado con el metodo de Canny y de Sobel. De este modo fue posible cumplir con los dos objetivoespecıficos en cuanto a la seleccion de los algoritmos con mayor velocidad de procesamiento.

Durante el desarrollo del proyecto se observo que el filtro de color Lab presento una mayor adaptacion a loscambios lumınicos, ya que los valores de los canales de matiz y saturacion logran abarcar estas variaciones,en cambio con los otros filtros, HSV y HSL perdıan su efectividad a diferentes horas del dıa por la variacionlumınica, obteniendo resultados muy diferentes al filtrar las imagenes capturadas.

En el desarrollo, en la seccion 4.1.3 se logro obtener una aproximacion que convierte los datos de profundidaddel sensor kinect a valores reales, y se comprobo la exactitud de la medida obteniendo una diferencia maxima±0,285cm entre el dato capturado por el sensor Kinect y la medicion realizada con un metro. Ademas, alenviar estos datos al microcontrolador de VEX, se verifico que las coordenadas calculadas son correctas, yaque el robot de prueba pudo ejecutar su tarea de recoger los objetivos en las coordenadas enviadas.

A traves de la Raspberry Pi fue posible enviar la informacion para controlar el robot de prueba, ejecutandolas rutinas de ir hasta el objetivo, recogerlo y regresar a su posicion de inicio para volver a buscar otros tresobjetivos. El sistema se programo para que recogiera cuatro pelotas en total y se puede observar su eficaciadel 88.3 % con las cinco pruebas realizadas cuyos resultados se pueden observar en el anexo A.6.

7.2. RecomendacionesPara que el sistema de vision artificial sea mucho mas eficiente, es recomendable utilizarlo en un ambientecontrolado, donde se pueda tener una iluminacion lo mas constante posible, hay que tener en cuenta tambienque al reconocer objetos naranjas, el sistema puede verse afectado por paredes o pisos de ladrillo, ya quepresentan diferentes tonalidades de naranja y puede aumentar la probabilidad de detectar un falso positivo.Adicionalmente las tomas de corriente de color naranja, al ser ovaladas y de un color naranja solido, tam-bien pueden llegar a ser detectadas, ya que algunos falsos positivos que se obtuvieron en las pruebas ROC dela seccion 6.1. Por estas razones, al trabajar en un ambiente controlado se pueden reducir los falsos positivos.

Una aplicacion de robotica movil, en el que se puede utilizar el sistema de vision artificial desarrollado eneste trabajo de grado, es un organizador de objetos esfericos en una planta industrial. Otro proyecto quepodrıa ser innovador, puede ser un sistema de vision artificial para la deteccion de otro tipo de objetos, porejemplo la deteccion de cajas para clasificarlas y ubicarlas en lugares especıficos dentro de una bodega deuna fabrica o industria, que con un codigo de colores se sepa a que zonas de la ciudad deben ser distribuidas,ahorrando el tiempo de embarque de los productos para ser transportados.

Se puede sugerir un mejor diseno en la regulacion del sensor kinect, se podrıa proponer un proyecto en elque se disene un conversor DC - DC para mejorar la regulacion realizada en este trabajo de grado, ya queel sensor kinect consume mucha corriente (340mA-DC aproximadamente) y puede consumir muy rapidola energıa almacenada en las baterıas. A pesar de que el regulador utilizado en este proyecto es suficiente,puede que en el campo de las competencias de VEX robotics, les pueda ser de utilidad, no solo para alimentarel sistema de vision artificial, sino tambien para alimentar el microcontrolador y tener una mayor duraciondurante competencia.

47

Referencias[1] Jon Aristondo Etxeberria. Algoritmo de reconocimiento de forma y color para una plataforma robotica.

Tesis de maestrıa, Universidad del Paıs Vasco/Euskal Herriko Unibertsitatea, 2010.

[2] M. G. Prado D. O. Sales D. F. Wolf y F.S. Osorio D. S. O. Correa, D. F. Sciotti. Mobile robotsnavigation in indoor environments using kinect sensor. In Second Brazilian Conference on CriticalEmbedded Systems (CBSEC). USP University - Sao Paulo, 2012.

[3] Vex robotics, Junio 2016. http://www.vexrobotics.com.

[4] VEX-Robotics. Nothing but net competition, Octubre 2015. http://www.vexrobotics.com/vexedr/competition/competition-history/nbn/.

[5] Omar Rodrıguez Zalapa, Antonio Hernandez Zavala, and Jorge Adalberto Huerta Ruelas. Sistema demedicion de distancia mediante imagenes para determinar la posicion de una esfera utilizando el sensorkinect xbox. Polibits, (49):59–68, 2014.

[6] Jinzi Mao. Tracking a tennis ball using image processing techniques. Tesis de maestrıa, Universidadde Saskatchewan-Saskatoon, Canada, 2006.

[7] Gloria Bueno Garcıa, Oscar Deniz Suarez, Jose Luis Espinosa Aranda, Jesus Salido Tercero, Ismael Se-rrano Gracia, and Noelia Vallez Enano. Learning Image Processing with OpenCV. Packt PublishingLtd, 2015.

[8] OpenCV. Source computer vision, Febrero 2016. http://opencv.org/.

[9] OpenCV. Miscellaneous image transformations, Julio 2016. http://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html.

[10] Nix Color Sensor. Introduction to the hsl color system, Junio 2016. https://nixsensor.com/what-is-hsl-color/.

[11] International Comition on Ilumination. Cie, Junio 2016. http://www.cie.co.at/.

[12] The Print Guide. Tolerancing color in presswork - cie l*a*b* and deltae,Agosto 2016. http://the-print-guide.blogspot.com.co/2010/04/tolerancing-color-in-presswork-cie-lab.html.

[13] Ramesh Jain, Rangachar Kasturi, and Brian G Schunck. Machine vision, volume 5. McGraw-Hill NewYork, 1995.

[14] OpenCV. Image filtering, Agosto 2016. http://docs.opencv.org/2.4/modules/imgproc/doc/filtering.html.

[15] Scikit-image. Filters, Agosto 2016. http://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.sobel.

[16] OpenCV. Feature detection, Agosto 2016. http://docs.opencv.org/2.4/modules/imgproc/doc/feature_detection.html.

[17] HK Yuen, John Princen, John Illingworth, and Josef Kittler. Comparative study of hough transformmethods for circle finding. Image and vision computing, 8(1):71–77, 1990.

[18] Joint Research Unit. Ground vehicle, Noviembre 2016. https://lafmia.hds.utc.fr/Ground_Vehicle.html.

48

http://www.vexrobotics.com

http://www.vexrobotics.com/vexedr/competition/competition-history/nbn/

http://www.vexrobotics.com/vexedr/competition/competition-history/nbn/

http://opencv.org/

http://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html

http://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html

https://nixsensor.com/what-is-hsl-color/

https://nixsensor.com/what-is-hsl-color/

http://www.cie.co.at/

http://the-print-guide.blogspot.com.co/2010/04/tolerancing-color-in-presswork-cie-lab.html

http://the-print-guide.blogspot.com.co/2010/04/tolerancing-color-in-presswork-cie-lab.html

http://docs.opencv.org/2.4/modules/imgproc/doc/filtering.html

http://docs.opencv.org/2.4/modules/imgproc/doc/filtering.html

http://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.sobel

http://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.sobel

http://docs.opencv.org/2.4/modules/imgproc/doc/feature_detection.html

http://docs.opencv.org/2.4/modules/imgproc/doc/feature_detection.html

https://lafmia.hds.utc.fr/Ground_Vehicle.html

https://lafmia.hds.utc.fr/Ground_Vehicle.html

[19] Razif Rashid, I Elamvazuthi, Mumtaj Begam, and M Arrofiq. Fuzzy-based navigation and control of anon-holonomic mobile robot. arXiv preprint arXiv:1003.4081, 2010.

[20] Katsuhiko Ogata. Ingenierıa de control moderna. Pearson Educacion, 2003.

[21] Universidad Don Bosco, Agosto 2016. http://www.udb.edu.sv/udb/archivo/guia/electronica-ingenieria/sistemas-de-control-automatico/2013/i/guia-5.pdf.

[22] Controle e Automacao. Controladores, Agosto 2016. http://controleeautomacao.blogspot.com.co/2011/09/controladores.html.

[23] Microsoft Developer Network. Kinect for windows sensor components and specifications, Octubre2015. https://msdn.microsoft.com/en-us/library/jj131033.aspx.

[24] Blogthinkbig. Kinect, un dispositivo mas alla del ocio, Febrero 2016. http://blogthinkbig.com/kinect-mas-alla-del-ocio/.

[25] Raspberry Pi. Downloads, Junio 2016. https://www.raspberrypi.org/downloads/.

[26] Raspberry Pi. Raspberry pi 3 model b, Abril 2016. https://www.raspberrypi.org/products/raspberry-pi-3-model-b/.

[27] Microsoft. Raspberry pi 2 & 3 pin mappings, Agosto 2016. https://developer.microsoft.com/en-us/windows/iot/docs/pinmappingsrpi.

[28] Scikit-Image. Image processing in python, Agosto 2016. http://scikit-image.org/.

[29] OpenKinect. Main page, Agosto 2016. https://openkinect.org/.

[30] Pyimagesearch. Install guide: Raspberry pi 3 + raspbian jessie + opencv3, Mayo 2016. http://www.pyimagesearch.com/2016/04/18/install-guide-raspberry-pi-3-raspbian-jessie-opencv-3/.

[31] TECNOMATIC ! GEEK BOT’S BLOG. Experimenting with kinect using opencv, python andopen kinect (libfreenect), Mayo 2016. https://naman5.wordpress.com/2014/06/24/experimenting-with-kinect-using-opencv-python-and-open-kinect-libfreenect/.

[32] NumPy, Junio 2016. http://www.numpy.org/.

[33] OpenKinect. Imaging information, Agosto 2016. https://openkinect.org/wiki/Imaging_Information.

[34] matplotlib, Agosto 2016. http://matplotlib.org/.

[35] VEXRobotics. Motors, Agosto 2016. http://www.vexrobotics.com/motors.html.

[36] VEX Robotics. Drivetrain geometry and turning, Noviembre 2016. http://curriculum.vexrobotics.com/curriculum/drivetrain-design/drivetrain-terminology-and-turning.

[37] RobotC. Making the robot turn, Agosto 2016. http://www.robotc.net/wikiarchive/Tutorials/Arduino_Projects/Mobile_Robotics/VEX/Turning.

[38] American University of Beirut. Receiver operating characteristics (roc) curve, Noviembre 2016.https://www.aub.edu.lb/sharp/Documents/ROC.pdf.

http://www.udb.edu.sv/udb/archivo/guia/electronica-ingenieria/sistemas-de-control-automatico/2013/i/guia-5.pdf



http://controleeautomacao.blogspot.com.co/2011/09/controladores.html

http://controleeautomacao.blogspot.com.co/2011/09/controladores.html

https://msdn.microsoft.com/en-us/library/jj131033.aspx

http://blogthinkbig.com/kinect-mas-alla-del-ocio/

http://blogthinkbig.com/kinect-mas-alla-del-ocio/

https://www.raspberrypi.org/downloads/

https://www.raspberrypi.org/products/raspberry-pi-3-model-b/

https://www.raspberrypi.org/products/raspberry-pi-3-model-b/

https://developer.microsoft.com/en-us/windows/iot/docs/pinmappingsrpi

https://developer.microsoft.com/en-us/windows/iot/docs/pinmappingsrpi

http://scikit-image.org/

https://openkinect.org/

http://www.pyimagesearch.com/2016/04/18/install-guide-raspberry-pi-3-raspbian-jessie-opencv-3/

http://www.pyimagesearch.com/2016/04/18/install-guide-raspberry-pi-3-raspbian-jessie-opencv-3/

https://naman5.wordpress.com/2014/06/24/experimenting-with-kinect-using-opencv-python-and-open-kinect-libfreenect/

https://naman5.wordpress.com/2014/06/24/experimenting-with-kinect-using-opencv-python-and-open-kinect-libfreenect/

http://www.numpy.org/

https://openkinect.org/wiki/Imaging_Information

https://openkinect.org/wiki/Imaging_Information

http://matplotlib.org/

http://www.vexrobotics.com/motors.html

http://curriculum.vexrobotics.com/curriculum/drivetrain-design/drivetrain-terminology-and-turning



http://www.robotc.net/wikiarchive/Tutorials/Arduino_Projects/Mobile_Robotics/VEX/Turning

http://www.robotc.net/wikiarchive/Tutorials/Arduino_Projects/Mobile_Robotics/VEX/Turning

https://www.aub.edu.lb/sharp/Documents/ROC.pdf

Anexos

50

A. AnexosA.1. Codigo del procesamiento de imagenes

1 # -*- coding: utf-8 -*-2 # Se importan las librerias a usar3 from freenect import*4 from numpy import*5 from cv2 import*6 from time import*7 try:8 from skimage import filters9 except ImportError:

10 from skimage import filter as filters11 from skimage.transform import hough_circle12 import sys1314 #Funcion de Adquisicion RGB kinect15 def frame_RGB():16 array,_ = sync_get_video()17 array = cvtColor(array,COLOR_RGB2BGR)18 return array1920 #Funcion para adquisicion de profundidad (depth) Kinect21 def frame_depth():22 array,_ = sync_get_depth()23 #array = array.astype(uint8)24 return array2526 #Funcion que retorna imagen binaria donde lo verde es blanco27 #y el resto es negro28 def filtLAB_Verde(img):29 lab = cvtColor(img, COLOR_BGR2Lab)30 # pongo los valores verdes para hacer la mascara31 #verde_bajo = array([35, 110, 138]) -> im1 #verde_bajo = array([34, 97,

143]) -> im132 #verde_alto = array([102, 136, 174]) -> im1 #verde_alto = array([126, 118,

174]) -> im133 #verde_bajo = array([44, 111, 144]) -> im2 #verde_bajo = array([32, 108,


153]) -> im235 #verde_bajo = array([20, 126, 132]) -> im3 #verde_bajo = array([60, 86,


179]) -> im337 verde_bajo = array([20, 76, 132])38 verde_alto = array([240, 121, 215])3940 mascara = inRange(lab, verde_bajo, verde_alto)4142 er = ones((7,7),uint8) #matriz para erosion4344 dil = array([[0,0,0,1,0,0,0],45 [0,1,1,1,1,1,0],46 [0,1,1,1,1,1,0],

51

47 [1,1,1,1,1,1,1],48 [0,1,1,1,1,1,0],49 [0,1,1,1,1,1,0],50 [0,0,0,1,0,0,0]],uint8) #matriz para dilatacion5152 mascara = erode(mascara,er,iterations = 1) #aplico erosion53 mascara = dilate(mascara,dil,iterations = 2) #aplico dilatacion54 return mascara555657 def filtLAB_Naranja(img):58 lab = cvtColor(img, COLOR_BGR2Lab)59 # pongo los valores de rango naranja para hacer la mascara60 #naranja_bajo = array([20, 146, 139]) -> im161 #naranja_alto = array([76, 168, 166]) -> im162 #naranja_bajo = array([35,147,144]) -> im263 #naranja_alto = array([152,172,187]) -> im264 #naranja_bajo = array([47, 136, 138]) -> im365 #naranja_alto = array([228, 183, 194]) -> im366 naranja_bajo = array([20, 136, 152])67 naranja_alto = array([235, 192, 198])6869 mascara = inRange(lab, naranja_bajo, naranja_alto)7071 er = ones((7,7),uint8) #matriz para erosion7273 dil = array([[0,0,0,1,0,0,0],74 [0,1,1,1,1,1,0],75 [0,1,1,1,1,1,0],76 [1,1,1,1,1,1,1],77 [0,1,1,1,1,1,0],78 [0,1,1,1,1,1,0],79 [0,0,0,1,0,0,0]],uint8) #matriz para dilatacion8081 # matriz para erosion y dilatacion82 mascara = erode(mascara,er,iterations = 1) #aplico erosion83 mascara = dilate(mascara,dil,iterations = 2)#aplico dilatacion84 return mascara8586 def buscar_pelotasVN():87 init=time()88 frame = frame_RGB() #leo frame89 depth = frame_depth() #leo profundidad depth90 depth = resize(depth,(0,0),fx=0.5, fy=0.5)91 showdepth = depth.astype(’uint8’)92 showdepth = cvtColor(showdepth, COLOR_GRAY2BGR)939495 mascaraV = resize(frame, (0,0), fx=0.5, fy=0.5)96 mascaraN = mascaraV97 frame = mascaraV98 frame = medianBlur(frame,5)99 #imwrite(’frame.jpg’,frame)

100101 color=time()102 mascaraV = filtLAB_Verde(frame)

52

103 mascaraN = filtLAB_Naranja(frame)104 tc=time()-color105106 edge=time()107108 #Toma el valor absoluto -> convertScaleAbs( grad_y, abs_grad_y )109 #explicacion Sobel_x + Sobel_y (addWeighted, suma grad_x y grad_y)110 #https://github.com/opencv/opencv/111 #blob/master/samples/cpp/tutorial_code/ImgTrans112 #/Sobel_Demo.cpp113114 nuevoV = filters.sobel(mascaraV)115 nuevoN = filters.sobel(mascaraN)116117 nuevoV = nuevoV.astype("int")118 nuevoN = nuevoN.astype("int")119 mascaraV[:,:] = nuevoV[:,:]*255120 mascaraN[:,:] = nuevoN[:,:]*255121122 diler = array([[0,1,0],123 [1,1,1],124 [0,1,0]],uint8) #Matriz para dilatacion y erosion125126 mascaraV = dilate(mascaraV,diler,iterations = 1) #aplico dilatacion127 mascaraN = dilate(mascaraN,diler,iterations = 1) #aplico dilatacion128129 te=time()-edge130131 #Hallo los circulos que esten en deteccion de bordes132133 circuloV = HoughCircles(mascaraV,HOUGH_GRADIENT, 1, 40, param1=60,134 param2=24,minRadius=0,maxRadius=0)135 circuloN = HoughCircles(mascaraN,HOUGH_GRADIENT, 1, 40, param1=60,136 param2=24,minRadius=0,maxRadius=0)137138 #Para obtener la distancia depV y depN se utilizo la informacion de esta139 #pagina: https://openkinect.org/wiki/Imaging_Information (Agosto 18)140 #Esa regresion se le hicieron modificaciones para disminuir el error141 #hallando una aproximacion de la forma 1/(Bx+C), donde x es el valor142 #en bytes obtenido por el sensor143144 #Para la alineacion145 cteX=9146 cteY=9 #Valores alineacion RGB y Depth 320 x 240 (18/2)147 #circle(rgb, (80-cteX,50+cteY),40,(0,0,255),5)148149 centimg = round(frame.shape[1]/2) #centro de la imagen donde son 0 grados

horizontal150 centVert= round(frame.shape[0]/2) #centro vertical 0 grados vertical151152 #Si encontro al menos un circulo153 if circuloV is not None:154 circuloV = circuloV.astype("int")155 xV = circuloV[0,0,0]156 xVd=xV + cteX157 yV = circuloV[0,0,1]

53

158 yVd=yV - cteY159 verde=True160 if xVd >= frame.shape[1]:161 xVd = 319162 if yVd >= frame.shape[0]:163 yVd = 239164 #Paso el pixel de coordenadas RGB a depth165 depV = 1/(depth[yVd,xVd]*(-0.0028642) + 3.15221) #para obtener dato es

en coordenada (y,x)->(480x640)166 depV = round(depV,4) #cuatro cifras decimales167 if depV < 0:168 depV=0169 else:170 verde = False171172 if circuloN is not None:173 circuloN = circuloN.astype("int")174 xN = circuloN[0,0,0]175 xNd=xN + cteX176 yN = circuloN[0,0,1]177 yNd=yN - cteY178 naranja=True179 if xNd >= frame.shape[1]:180 xNd = 319181 if yNd >= frame.shape[0]:182 yNd = 239183 #para obtener dato es en coordenada (y,x)->(480x640)184 depN = 1/(depth[yNd,xNd]*(-0.0028642) + 3.15221)185 depN = round(depN,4) #cuatro cifras decimales186 if depN < 0:187 depN=0188 else:189 naranja = False190191 if naranja or (verde and naranja):192 c1,c2=1,0193 bethaN = abs(centVert - yNd)*0.17916 #0.17916 son grados/Px en vertical

(43grad/240)194 bethaN = (bethaN*pi)/180195 depN = depN*cos(bethaN) # centro valor vertical para ubicar la

distancia en 0grad Vertical196 alphaN = (xNd - centimg)*0.1781 #0.1781 son los grados por pixel

(grad/px) 320 x 240197 alphaN = (alphaN*pi)/180 # en radianes198 xm = depN*sin(alphaN)199 ym = depN*cos(alphaN)200 elif verde and (not naranja):201 c1,c2=0,1202 bethaV = abs(centVert - yVd)*0.17916 #0.17916 son drad/Px en vertical

(43grad/240)203 bethaV = (bethaV*pi)/180204 depV = depV*cos(bethaV) # centro valor vertical para ubicar la

distancia en 0grad Vertical205 alphaV = (xVd - centimg)*0.1781 #0.1781 son los grados por pixel

(grad/px)206 alphaV = (alphaV*pi)/180 # en radianes

54

207 xm = depV*sin(alphaV)208 ym = depV*cos(alphaV)209 else:210 c1,c2=0,0211 xm,ym=0,0212213 t=time()-init214 print(’FIN’,t,’EDGES’,te,’COLOR’,tc)215 # print(’c1’,c1,’c2’,c2,’xm’,xm,’ym’,ym)216 #imshow(’NARANJA’,mascaraN)217 #waitKey(1)218 #imshow(’VERDE’,mascaraV)219 #waitKey(1)220 #imshow(’FRAME’,frame)221 #waitKey(1)222 return(c1, c2, xm, ym)

55

A.2. Codigo de Python para la comunicacion serial

1 # -*- coding: utf-8 -*-2 import RPi.GPIO3 from numpy import array4 #from buscar_pelotasVN_LaplaceHSV import*5 #from buscar_pelotasVN_CannyHSL import*6 from buscar_pelotasVN_LaplaceLab import*7 #from buscar_pelotasVN_SobelLabX import*8 import time9

10 # Relacion de los pines GPIO Numero11 RPi.GPIO.setmode(RPi.GPIO.BOARD)1213 #Configuracion de pines de salida14 # Salida serial15 RPi.GPIO.setup(36,RPi.GPIO.OUT)1617 # Listo Raspberry18 RPi.GPIO.setup(38,RPi.GPIO.OUT)1920 #Configuracion de pines de entrada21 #Puede recibir datos: Vex Arm Cortex22 RPi.GPIO.setup(40,RPi.GPIO.IN)23 #while (c1 is 0) and (c2 is 0):24 #while True:2526 a=([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])2728 #Enviar datos de manera serial a Vex Arm Cortex29 try:30 while True:31 TIEMPOT=time.time()32 c1,c2 = 0,033 RPi.GPIO.output(38,True) # logica negada (0)34 # No esta listo para envio35 c1,c2,numx,numy=buscar_pelotasVN() #VISION ARTIFICIAL36 if numy > 0:37 print(’numx’,numx,’numy’,numy)38 #Convierto el valor entre 0 y 255 donde 2 m39 #es el maximo valor en metros de ym40 numy = int(255*numy/2)4142 #igual para x, donde el primer bit es el signo + o -43 #y el valor maximo en x es de 1.677 m44 if numx < 0:45 a[2]=146 numx= int(127*numx*(-1)/1.677)47 else:48 numx= int(127*numx/1.677)49 a[2]=05051 a[0]=c152 a[1]=c25354 print(’numx’,numx,’numy’,numy)

56

5556 #conversion a envio serial57 for j in range(0,7):58 a[9-j] = int(numx%2)59 numx=numx/260 #print (a[9-j],9-j,"dato",numx)6162 for k in range(0,8):63 a[17-k]= int(numy%2)64 numy=numy/265 #print (a[17-k],17-k,"dato",numy)6667 print(a)68 #break6970 #ENVIO DE LA TRANSMISION EN CASO DE VexListo71 i=072 vexlisto=RPi.GPIO.input(40)73 if vexlisto:74 print(’***CORTEX_LISTO***->’, vexlisto)75 tiemp=076 sta=time.time()77 while (i<18 and tiemp<10):78 vexlisto=RPi.GPIO.input(40)79 # print(’***CORTEX_LISTO***->’, vexlisto)80 pao=081 while vexlisto==1:8283 vexlisto=RPi.GPIO.input(40)84 RPi.GPIO.output(38,False) # es 1 (logica negada)85 RPi.GPIO.output(36,not(a[i])) #not -> logica negada86 pao=187 if pao==1:88 RPi.GPIO.output(38,True) # es 0 (logica negada)89 #print(a[i],"dato",i,’IIII’)90 i=i+191 tiemp=time.time()-sta92 # break9394 print(’TOTALconTx’,time.time() - TIEMPOT)9596 except KeyboardInterrupt:97 RPi.GPIO.cleanup()

57

A.3. Codigo de RobotC para el microcontrolador ARM Cortex de VEX

1 #pragma config(I2C_Usage, I2C1, i2cSensors)2 #pragma config(Sensor, dgtl1, Serial, sensorTouch)3 #pragma config(Sensor, dgtl2, ListoRasp, sensorTouch)4 #pragma config(Sensor, dgtl3, ListoVex, sensorDigitalOut)5 #pragma config(Sensor, dgtl4, LEDNaranja, sensorDigitalOut)6 #pragma config(Sensor, dgtl5, LEDVerde, sensorDigitalOut)7 #pragma config(Sensor, I2C_1, EnDerecha, sensorQuadEncoderOnI2CPort, ,

AutoAssign)8 #pragma config(Sensor, I2C_2, EnIzquierda, sensorQuadEncoderOnI2CPort, ,

AutoAssign)9 #pragma config(Motor, port1, Derecha, tmotorVex393, PIDControl, reversed,

encoder, encoderPort, I2C_1, 1000)10 #pragma config(Motor, port2, Arriba, tmotorVex393, openLoop, reversed)11 #pragma config(Motor, port10, Izquierda, tmotorVex393, PIDControl, reversed,

encoder, encoderPort, I2C_2, 1000)12 //*!!Code automatically generated by ’ROBOTC’ configuration wizard !!*//1314 #pragma platform(VEX)15 #pragma autonomousDuration(70)16 #include "Vex_Competition_Includes.c"1718 //*!!Code automatically generated by ’ROBOTC’ configuration wizard !!*//19 //***************************************mover

motores******************************//20 void pre_auton()21 {2223 }24 int datoG[3];25 //********************Giro a la

Derecha********************************************//26 void GirarDerecha(float grados)27 {28 nMotorEncoder[Derecha]=0;29 nMotorEncoder[Izquierda]=0;30 int ticks=0;31 int giro90=1738; //Ticks por giro de 90 grados32 ticks=-(((giro90*grados)/90)-40);//4033 //if(grados>23){34 // ticks=-(((giro90*grados)/90)-90);35 //}3637 while(nMotorEncoder[Derecha]>ticks)38 {39 datoG[0]=nMotorEncoder[Derecha];40 datoG[2]=nMotorEncoder[Izquierda];41 datoG[1]=ticks;42 motor[Derecha]=-100;43 motor[Izquierda]=-100;44 }45 motor[Derecha]=0;46 motor[Izquierda]=0;47 }

58

48 //********************Giro a laIzquierda********************************************//

49 void GirarIzquiera(float grados)50 {51 nMotorEncoder[Derecha]=0;52 nMotorEncoder[Izquierda]=0;53 int ticks=0;54 int giro90=1738; //Ticks por giro de 90 grados55 ticks=(((giro90*grados)/90)+55);//405657 if(grados>23){58 ticks=((giro90*grados)/90);// tenia 10059 }6061 while(nMotorEncoder[Derecha]<ticks)62 {63 datoG[0]=nMotorEncoder[Derecha];64 datoG[2]=nMotorEncoder[Izquierda];65 datoG[1]=ticks;66 motor[Derecha]=127;67 motor[Izquierda]=100;68 }69 motor[Derecha]=0;70 motor[Izquierda]=0;71 wait1Msec(100);72 }73 //**********************************AVANZAR******************************************//74 void Avanzar(float cm)75 {76 nMotorEncoder[Derecha]=0;77 nMotorEncoder[Izquierda]=0;78 int vueltas=0;79 float perimetro=0;80 float diametro=2.75*2.5;81 perimetro= diametro*PI;82 vueltas=(388*(cm-8))/perimetro;83 while(nMotorEncoder[Izquierda]<vueltas)84 {85 motor[Derecha]=-40;86 motor[Izquierda]=40;87 }88 motor[Derecha]=0;89 motor[Izquierda]=0;90 }91 //*************************************RETROCEDER***********************************//92 void Retroceder(float cm)93 {94 nMotorEncoder[Derecha]=0;95 nMotorEncoder[Izquierda]=0;96 int vueltas=0;97 float perimetro=0;98 float diametro=2.75*2.5;99 perimetro= diametro*PI;

100 vueltas=-(388*(cm-8))/perimetro;101 while(nMotorEncoder[Izquierda]>vueltas)102 {

59

103 motor[Derecha]=40;104 motor[Izquierda]=-40;105 }106 motor[Derecha]=0;107 motor[Izquierda]=0;108 }109110 //********************************ENTRADA DATO RASPBERRY PI

3***********************//111 // variables globales112 int Dato[18];113 int chepe=0;114 int i=0;115 int entero[2];116 float datof[2];117 int signo=1;118119 void RecibirDatos(){120 i=0;121 Dato[0]=0;122 Dato[1]=0;123 Dato[2]=0;124 Dato[3]=0;125 Dato[4]=0;126 Dato[5]=0;127 Dato[6]=0;128 Dato[7]=0;129 Dato[8]=0;130 Dato[9]=0;131 Dato[10]=0;132 Dato[11]=0;133 Dato[12]=0;134 Dato[13]=0;135 Dato[14]=0;136 Dato[15]=0;137 Dato[16]=0;138 Dato[17]=0;139 datof[0]=0;140 datof[1]=0;141 entero[0]=0;142 entero[1]=0;143 SensorValue(ListoVex)=1;144 while(i<18){// recibir datos de manera serial sinc145 chepe=3;146 SensorValue(ListoVex)=1;147 while(SensorValue(ListoRasp)==1){148149 if(SensorValue(Serial)==1)150 {151 Dato[i]=1;152 chepe=1;153 SensorValue(ListoVex)=0;154 }155 else {156 Dato[i]=0;157 chepe=1;

60

158 SensorValue(ListoVex)=0;159 }160 }161 if (chepe==1){162 i++;163 }164 }165 wait1Msec(10);166 SensorValue(ListoVex)=0;167168 //***************** convertir dato de binario a float ***********//169170 int a;171 int b;172 entero[1]=0;173 entero[0]=0;174 a=0;175 b=6;176 signo=1;177 //signo parametro x178 if(Dato[2]==1){179 signo=-1;180 }181 //dato de x,y tipo float182 for(int i=3;i<18;i++){183184 // dato y apartir del dato 10185 if(i==10){186 b=7;187 a=1;188 signo=1;189 }190191 entero[a]=entero[a]+Dato[i]*pow(2,b)*signo;192 writeDebugStreamLine("entero %d y %d dato a %d",entero[a],Dato[i],a);193194 b=b-1;195 }196 //conversion x197 datof[0]=(((entero[0]*1.677)/127)*100);198 datof[1]=((entero[1]*1.99999)/255)*100;// conversion y -6199200 }201 //********************************CONVERTIR A GRADOS Y MAGNITUD

*************************//202 // Variables locales203 float Magnitud;204 float Angulo;205206 void Convertir(){207 float antes=0;208 Magnitud=0;209 Angulo=0;210 if(Dato[2]==1){211 signo=-1;212 }

61

213 Angulo=((atan(((datof[0])/(datof[1]*signo)))*180)/PI);214215 antes=pow(datof[1],2)+pow(datof[0],2);216 Magnitud=sqrt(antes);217218 if (Magnitud > 199){219 Magnitud=199;220 }221222223 }224 //****************************************************MAIN**************************************************225 int repetir=0;226 task autonomous()227 {228 SensorValue(LEDNaranja)=0;229 SensorValue(LEDVerde)=0;230 int error=0;231232 while(repetir<4){233 SensorValue(LEDNaranja)=0;234 SensorValue(LEDVerde)=0;235 error=0;236 clearDebugStream();237 RecibirDatos();238 Convertir();239240 if(Dato[0]==1){241 SensorValue(LEDNaranja)=1;242 }243 else{244 if(Dato[1]==1){245 SensorValue(LEDVerde)=1;246 }247 }248249250 if(Angulo>35){251 error=1;252 }253 if (error==0){254 if (Dato[2]==1){255 GirarIzquiera(Angulo);256 }257 else {258 GirarDerecha(Angulo);259 }260261 Avanzar(Magnitud+12);262 motor[Arriba]=0;263 wait1Msec(100);264 motor[Arriba]=127;265 wait1Msec(100);266 motor[Arriba]=0;267 wait1Msec(100);268

62

269 Retroceder(Magnitud);270 wait1Msec(700);271272 if (Dato[2]==1){273 GirarDerecha(Angulo);274 }275 else {276 GirarIzquiera(Angulo);277 }278279 wait1Msec(100);280281 wait1Msec(900);282 motor[Arriba]=0;283 wait1Msec(1500);284 motor[Arriba]=-127;285 wait1Msec(3000);286 motor[Arriba]=0;287288 repetir++;289 SensorValue(LEDNaranja)=0;290 SensorValue(LEDVerde)=0;291 }292293 }294 SensorValue(ListoVex)=0;295 }296297 task usercontrol()298 {

63

A.4. Codigo de obtencion de datos de los motores con RobotC

1 #pragma config(I2C_Usage, I2C1, i2cSensors)2 #pragma config(Sensor, I2C_1, EnDerecha, sensorQuadEncoderOnI2CPort, ,

AutoAssign)3 #pragma config(Sensor, I2C_2, EnIzquierda, sensorQuadEncoderOnI2CPort, ,

AutoAssign)4 #pragma config(Motor, port1, Derecha, tmotorVex393, PIDControl, reversed,

encoder, encoderPort, I2C_1, 1000)5 #pragma config(Motor, port2, Arriba, tmotorVex393, openLoop, reversed)6 #pragma config(Motor, port10, Izquierda, tmotorVex393, PIDControl, reversed,

encoder, encoderPort, I2C_2, 1000)7 //*!!Code automatically generated by ’ROBOTC’ configuration wizard !!*//89 #pragma platform(VEX)

10 //*!!Code automatically generated by ’ROBOTC’ configuration wizard !!*//11 int datoI;121314 // control de motor con angulo15 task main()16 {17 // se inicializa los encoders1819 // Giran al lado derecha20 motor[Derecha]=127;2122 wait1Msec(3000);2324 nMotorEncoder[Derecha]=0;2526 wait1Msec(1000);2728 datoI=nMotorEncoder[Derecha];2930 wait1Msec(1000);3132 motor[Derecha]=0;3334 //Parar los motores3536 }

64

Los datos obtenidos se encuentran a continuacion:

Figura A.1: Datos adquiridos para la caracterizacion de los motores

65

A.5. Resultados de las pruebas ROCTablas del registro de las pruebas:

Figura A.2: Datos registrados de las pruebas ROC



66

A.6. Desempeno del robot de PruebaTablas del registro de las pruebas:

Figura A.5: Datos registrados del desempeno del robot de prueba

67


68


69


70


71

Date post:	20-Nov-2021
Category:	Documents
Upload:	others
View:	3 times
Download:	0 times