aplicaciÓn demostrativa de robÓtica industrial y …

TRABAJO DE FIN DE GRADO

Grado en Ingeniería Electrónica Industrial y Automática

APLICACIÓN DEMOSTRATIVA DE ROBÓTICA INDUSTRIAL Y

VISIÓN POR COMPUTADOR

Memoria y Anexos

Autor: Ángel Márquez Sayavera Director: Sebastián Tornil Sin Co-Director: Gerard Escudero Bakx Convocatoria: Junio 2020

Aplicación Demostrativa de Robótica Industrial y Visión por Computador

i

Resum

En el present document es descriu el Treball de Fi de Grau (TFG) realitzat amb la fi de dissenyar i

implementar una aplicació demostrativa de robòtica industrial i visió per computador que pugui ser

mostrada al públic durant els dies de portes obertes de l’Escola d’Enginyeria de Barcelona Est (EEBE).

D’aquesta manera, es pretén despertar l’interès dels assistents en realitzar el grau d’Enginyeria

Electrònica Industrial i Automàtica.

La demostració està formada per un ordinador, una càmera i un robot Mitsubishi RV-2AJ.

Concretament, consisteix en que un usuari introdueix el seu nom per teclat en la interfície gràfica de

l’ordinador i, mitjançant la captura d’una imatge amb la càmera i algoritmes d’intel·ligència artificial i

tècniques de visió per computador, el robot és capaç de col·locar ordenadament una sèrie de peces

cúbiques que l’usuari ha distribuït prèviament pel tauler, formant finalment el seu nom amb les lletres

posicionades a les cares d’aquests cubs.

En aquest projecte es poden trobar dues parts clarament diferenciades. Una part d’intel·ligència

artificial i visió per computador, on s’adquireix la imatge per obtenir el reconeixement de les lletres

observades i les seves corresponents posicions i orientacions, tot això resumit en una interfície gràfica

programada amb Python. I, per altra part, una part de robòtica, on el robot rep les dades transmeses

per comunicació en sèrie RS-232 i executa una rutina programada amb MELFA BASIC IV per recollir i

col·locar les peces en l’ordre correcte fins formar el nom de l’usuari.

Paraules clau: Robòtica, Visió per computador, Intel·ligència artificial, Mitsubishi RV-2AJ, Python,

MELFA BASIC.

Memoria

ii

Resumen

En el presente documento se describe el Trabajo de Fin de Grado (TFG) realizado con el fin de diseñar

e implementar una aplicación demostrativa de robótica industrial y visión por computador que pueda

ser mostrada al público durante los días de puertas abiertas de la Escuela de Ingeniería de Barcelona

Este (EEBE). De esta manera, se pretende despertar el interés de los asistentes en realizar el grado de

Ingeniería Electrónica Industrial y Automática.

La demostración está formada por un ordenador, una cámara y un robot Mitsubishi RV-2AJ.

Concretamente, consiste en que un usuario introduce su nombre por teclado en la interfaz gráfica del

ordenador y, mediante la captura de una imagen con la cámara y algoritmos de inteligencia artificial y

técnicas de visión por computador, el robot es capaz de colocar ordenadamente una serie de piezas

cúbicas que el usuario ha distribuido previamente por el tablero, formando finalmente su nombre con

las letras posicionadas en las caras de dichos cubos.

En este proyecto se pueden encontrar dos partes claramente diferenciadas. Una parte de inteligencia

artificial y visión por computador, donde se adquiere y se procesa la imagen para obtener el

reconocimiento de las letras observadas y sus correspondientes posiciones y orientaciones, todo ello

resumido en una interfaz gráfica programada en Python. Y, por otra parte, una parte de robótica,

donde el robot recibe los datos transmitidos por comunicación en serie RS-232 y ejecuta una rutina

programada en MELFA BASIC IV para recoger y colocar las piezas en el orden correcto hasta formar el

nombre del usuario.

Palabras clave: Robótica, Visión por computador, Inteligencia artificial, Mitsubishi RV-2AJ, Python,

MELFA BASIC IV.


iii

Abstract

The present document describes the Final Project Degree carried out in order to design and implement

a demonstration application of industrial robotics and computer vision that can be shown to the public

during the open doors days of the School of Engineering of Barcelona East (EEBE). In this way, it is

intended to arouse the interest of attendees in the degree of Industrial Electronica and Automatic

Engineering.

The demonstration consists of a computer, a camera and a Mitsubishi RV-2AJ robot. Specifically, the

demonstration consists in that a user enters his name by keyboard in the graphic interface on the

computer and, by capturing an image with the camera and artificial intelligence algorithms and

computer vision techniques, the robot is capable of placing a series of cubic pieces that the user has

previously distributed on the board the board in the correct order, finally forming the name of the user

with the letters positioned on the faces of these cubes.

In this project, you can find two clearly differentiated parts. A part of artificial intelligence and

computer vision, where the image is acquired and processed to obtain recognition of the letters

observed and their corresponding positions and orientations, all summarized in a graphical interface

programmed in Python. And, on the other hand, a part of robotics, where the robot receives the data

transmitted by RS-232 serial communication and executes a routine programmed in MELFA BASIC IV

to collect and place the pieces on the correct order until the user’s name is formed.

Keywords: Robotics, Computer Vision, Artificial Intelligence, Mitsubishi RV-2AJ, Python, MELFA BASIC

IV.

Memoria

iv

Agradecimientos

El más especial, a mi tutor Sebastián Tornil por haberme permitido llevar a cabo la realización de este

TFG con él, ayudarme en todas las dudas que han surgido sobre robótica a lo largo de la elaboración

del proyecto y guiarme por el mejor camino posible. Gracias a él he sido capaz de realizar una aplicación

que, inicialmente, no pensaba que fuera a ser capaz, por lo que no puedo estar más agradecido.

A mi cotutor, Gerard Escudero, por haberme ayudado gracias a sus conocimientos en inteligencia

artificial, aprendizaje profundo y redes neuronales siempre que lo he necesitado.

A los técnicos del taller de la planta 5 de la EEBE, por no importarle las molestias que he podido

causarles para que me dieran acceso al laboratorio cada vez que necesitaba entrar.


v

Memoria

vi

Índice

RESUM ______________________________________________________________ I

RESUMEN __________________________________________________________ II

ABSTRACT __________________________________________________________ III

AGRADECIMIENTOS __________________________________________________ IV

1. INTRODUCCIÓN _________________________________________________ 2

1.1. Motivación personal y origen del trabajo ............................................................... 2

1.2. Objetivos y alcance .................................................................................................. 3

1.3. Fases de desarrollo .................................................................................................. 4

2. MARCO TEÓRICO ________________________________________________ 5

2.1. La robótica industrial ............................................................................................... 5

2.1.1. Origen de la palabra robot y antecedentes históricos ........................................... 5

2.1.2. Definición de robot industrial y clasificación .......................................................... 7

2.1.3. Aplicaciones de la robótica industrial ..................................................................... 8

2.2. La visión por computador ........................................................................................ 9

2.2.1. Definición de visión por computador y formación de imágenes ........................... 9

2.2.2. Etapas del sistema de visión por computador ..................................................... 10

2.2.3. La imagen digital y tipos de imágenes .................................................................. 10

2.2.4. Reconocimiento óptico de caracteres .................................................................. 12

2.3. Inteligencia artificial y Redes Neuronales Convolucionales (CNN) ....................... 12

2.3.1. La inteligencia artificial y el aprendizaje supervisado .......................................... 12

2.3.2. Redes neuronales artificiales y Deep Learning ..................................................... 13

2.3.3. Redes Neuronales Convolucionales (CNN) ........................................................... 16

3. EL SISTEMA ROBOT _____________________________________________ 19

3.1. Brazo robótico RV-2AJ ........................................................................................... 19

3.2. Controlador CR1-571 ............................................................................................. 22

3.3. Consola de programación R28TB .......................................................................... 24

4. HERRAMIENTAS UTILIZADAS ______________________________________ 26

4.1. Programación del robot ......................................................................................... 26

4.1.1. El lenguaje MELFA BASIC IV .................................................................................. 26

4.1.1.1. Instrucciones de control de movimiento ........................................................... 27


vii

4.1.1.2. Instrucciones de control de programa ............................................................... 29

4.1.1.3. Instrucciones de comunicaciones ...................................................................... 31

4.1.2. RT Toolbox 2 ......................................................................................................... 31

4.2. Programación visión artificial PC ........................................................................... 32

4.2.1. Python y Spyder .................................................................................................... 32

4.2.2. OpenCV ................................................................................................................. 33

4.2.3. TensorFlow ........................................................................................................... 33

4.2.4. Keras ..................................................................................................................... 34

4.2.5. Scikit-learn ............................................................................................................ 34

4.2.6. Pandas................................................................................................................... 35

4.2.7. Tkinter ................................................................................................................... 35

5. DISEÑO DE PIEZAS Y ESPACIO DE TRABAJO __________________________ 36

5.1. Determinación del número de piezas ................................................................... 36

5.2. Diseño de piezas..................................................................................................... 38

5.3. Espacio de trabajo .................................................................................................. 39

5.4. Ubicación de la cámara .......................................................................................... 40

6. EXTRACCIÓN Y LOCALIZACIÓN DE REGIONES DE INTERÉS (ROIS) _________ 42

6.1. Detección y extracción de regiones de interés (ROIs)........................................... 42

6.1.1. Conversión de la imagen a escala de grises ......................................................... 42

6.1.2. Filtrado de la imagen para reducir el ruido .......................................................... 44

6.1.3. Binarización de la imagen ..................................................................................... 45

6.1.4. Búsqueda de contornos ....................................................................................... 48

6.1.5. Extracción de regiones de interés (ROIs) ............................................................. 49

6.2. Transformación de coordenadas ........................................................................... 51

6.2.1. Búsqueda del centro de las ROIs en la imagen .................................................... 51

6.2.2. Experimento de regresión de las coordenadas reales ......................................... 53

6.2.2.1. Creación del conjunto de datos de entrenamiento ........................................... 53

6.2.2.2. Regresión de las coordenadas reales de la imagen ........................................... 54

7. RECONOCIMIENTO DE LETRAS Y ORIENTACIÓN _______________________ 60

7.1. Experimento 1: CNN reconocimiento de letras .................................................... 60

7.1.1. Selección del conjunto de datos de entrenamiento ............................................ 60

7.1.2. Definición de la arquitectura de la red CNN ........................................................ 63

7.1.3. Entrenamiento de la red ...................................................................................... 64

7.1.3.1. Función de pérdidas y exactitud ........................................................................ 65

Memoria

viii

7.1.3.2. Selección del optimizador .................................................................................. 65

7.1.3.3. Selección del tamaño de lote (batch_size) ........................................................ 66

7.1.3.4. Selección del número de épocas (epochs) ........................................................ 67

7.1.4. Obtención de resultados ....................................................................................... 70

7.2. Experimento 2: Detección del ángulo de inclinación de las ROIs ......................... 75

7.3. Experimento 3: CNN reconocimiento de letras rotadas ....................................... 78

7.4. Experimento 4: Detección orientación 0-90-180-270 .......................................... 86

8. IMPLEMENTACIÓN DE LA APLICACIÓN ______________________________ 92

8.1. Interfaz Gráfica de Usuario (GUI) y comunicación RS-232 ................................... 92

8.1.1. Diseño de la GUI .................................................................................................... 93

8.1.2. Comunicación por puerto serie RS-232 ................................................................ 96

8.2. Programación del robot RV-2AJ ............................................................................ 97

9. PRESUPUESTO Y ANÁLISIS ECONÓMICO ____________________________ 100

9.1. Costes de personal ............................................................................................... 100

9.2. Costes de material ............................................................................................... 101

10. CONCLUSIONES _______________________________________________ 102

Trabajo futuro ................................................................................................................ 103

BIBLIOGRAFÍA _____________________________________________________ 104

ANEXOS __________________________________________________________ 106

A1. Código Python Modelos de regresión .................................................................... 106

A2. Código Python CNN Reconocimiento de letras ...................................................... 107

A3. Código Python detección del ángulo de inclinación de las ROIs ............................ 110

A4. Código Python CNN reconocimiento letras rotadas .............................................. 112

A5. Código de la interfaz de la aplicación ..................................................................... 115

A6. Programación MELFA robot .................................................................................... 122


1

Memoria

2

1. Introducción

En este primer capítulo se explica una introducción al proyecto que se va a exponer en este documento.

Se menciona la motivación personal hacia las temáticas involucradas y el origen del trabajo realizado,

definiendo sus objetivos y alcance y explicando las distintas fases que han de ser desarrolladas para

dar por finalizado el proyecto.

1.1. Motivación personal y origen del trabajo

La elección de este proyecto ha sido motivada por mi atracción a la programación, la robótica y la

inteligencia artificial. Estas tres temáticas me permitían realizar un proyecto completo en el que cada

una de ellas desempeñara una parte importante de este. De esta forma, utilizando mis conocimientos

en estos ámbitos y mi propia imaginación, era posible llevar a cabo el diseño y los códigos oportunos

con el fin de satisfacer los objetivos del proyecto.

Además, el poder adentrarme por primera vez en solitario en el mundo de la robótica gracias al robot

disponible en el laboratorio y poder observar unos resultados visibles a medida que se avanza era algo

que no podía dejar escapar.

Este proyecto surge con la idea de mejorar una demostración de robótica y visión por computador

observada en un video llamado Alphabot, del Museo Nacional de Escocia [1]. En el video se puede

visualizar un brazo robótico rodeado por cubos en cuyas caras tienen una letra distinta del abecedario,

algunas de estas letras repetidas con el fin de ser capaz de formar los distintos nombres de los usuarios.

Cuando el usuario entra su nombre por teclado y da la orden de empezar, el robot, que ya conoce la

posición de los distintos cubos y las caras donde están situadas las letras, procede a recoger los cubos

y llevarlos a la posición adecuada para formar el nombre deseado.

Esta aplicación demostrativa de robótica ha podido ser implementa gracias al permiso para acceder al

laboratorio de Automatización y Robótica Industrial de la EEBE, lugar en el cual se encuentra el brazo

robótico y su controlador.


3

1.2. Objetivos y alcance

El objetivo principal del proyecto es la mejora de la aplicación explicada en el apartado anterior,

concretamente, se trata de desarrollar una aplicación que permita al usuario introducir su nombre y el

brazo robótico sea capaz de construir el nombre adecuadamente colocando, de manera ordenada,

unos cubos en cuyas caras tienen una letra distinta del abecedario.

La diferencia entre la aplicación original y la que se procede a realizar es conseguir que el sistema

diseñado sea capaz de reconocer mediante visión artificial la posición y orientación de cada uno de los

cubos y sus correspondientes letras en el espacio de trabajo, con el fin de que esta posición sea

transmitida al robot y que pueda ser variada, de forma que no tenga que estar establecida de forma

fija al inicio de la aplicación.

Concretamente, el funcionamiento de la aplicación demostrativa desarrollada en este proyecto es el

siguiente:

1. El usuario introduce su nombre mediante la interfaz de la aplicación ejecutada en el PC.

2. El usuario distribuye los cubos necesarios de forma arbitraria dentro de una determinada zona

al alcance del robot.

3. La aplicación determina la localización y orientación de los cubos y reconoce las letras visibles

sobre ellos mediante técnicas de visión por computador e inteligencia artificial.

4. El robot recoge los distintos cubos y los coloca sobre un soporte hasta representar el nombre

del usuario.

Por lo tanto, el proyecto desarrolla tanto la programación necesaria para el control del robot en MELFA

BASIC IV como la programación necesaria en Python para la parte de visión por computador y la

interfaz del usuario.

Fig. 1.1. Funcionamiento de la aplicación.

Memoria

4

1.3. Fases de desarrollo

Con el fin de llevar a cabo una correcta organización de las distintas tareas necesarias para realizar el

proyecto, este se puede dividir en cuatro fases de desarrollo diferentes:

1. Diseño de piezas y espacio de trabajo: Se establece el número de piezas necesarias, con las

distintas letras adhesivas en sus respectivos lados, para poder formar la mayor cantidad de

nombres posibles que puedan ser introducidos por el usuario. Además, se realiza el diseño

tanto de estos cubos como del espacio de trabajo, con el objetivo de conseguir una correcta

visualización desde la cámara y facilitar el reconocimiento de las distintas letras del

abecedario.

2. Extracción y localización de regiones de interés (ROIs): Se utilizan las técnicas adecuadas de

visión por computador para el preprocesamiento de la imagen capturada con la cámara,

llevando a cabo la binarización y la extracción de caracteres. Por otra parte, se emplean

algoritmos de inteligencia artificial para determinar la localización de las distintas letras

situadas en el tablero.

3. Reconocimiento de letras y orientación: Se utilizan redes neuronales convolucionales con el

objetivo de llevar a cabo el reconocimiento de las letras contenidas en los cubos capturados

por la cámara y también conocer sus respectivas orientaciones.

4. Implementación de la aplicación: Se diseña la interfaz gráfica de usuario (GUI) y se establece

una correcta comunicación por puerto serie entre el ordenador y el robot Mitsubishi para

hacer posible la integración del sistema al completo. Finalmente, se debe realizar la

programación del robot en lenguaje MELFA BASIC IV para que sea capaz de transportar las

distintas piezas de forma eficaz y colocar el nombre del usuario correctamente sobre el

soporte.


5

2. Marco teórico

En este capítulo se presenta el marco teórico relacionado con este trabajo. En primer lugar, se presenta

una introducción a la robótica industrial, explicando sus antecedentes históricos más relevantes, las

distintas clasificaciones de robots industriales y algunas aplicaciones industriales de la robótica.

Seguidamente, se procede a describir la visión por computador, mencionando las etapas de un sistema

de visión artificial, además de que se introduce la imagen digital y los sistemas de reconocimiento

óptico de caracteres. Finalmente, se presenta una explicación del término de inteligencia artificial,

diferenciando los distintos tipos de aprendizaje automático y se presentan las redes neuronales, en

concreto, las redes neuronales convolucionales.

2.1. La robótica industrial

2.1.1. Origen de la palabra robot y antecedentes históricos

A lo largo de la historia, los humanos han sentido atracción por máquinas que imitan las funciones y

movimientos de los seres vivos, las cuales fueron denominadas como “automatos” por los griegos.

Entre los siglos XIV y XIX se construyeron multitud de autómatas, aunque el término robot fue utilizado

por primera vez en el año 1921, cuando el escritor checo Karel Capek estrena su obra Rossum’s

Universal Robots (R.U.R) en el teatro nacional de Praga. Su origen es la palabra eslava “robota”, que se

refiere al trabajo realizado de manera forzada. [2]

Sin embargo, el máximo impulsor de esta palabra fue el escritor Isaac Asimov, quien enunció sus tres

leyes de la robótica en 1945

1. Un robot no puede perjudicar a un ser humano, ni con su inacción permitir que un ser humano

sufra daño.

2. Un robot ha de obedecer las órdenes recibidas de un ser humano, excepto si tales órdenes

entran en conflicto con la primera ley.

3. Un robot debe proteger su propia existencia mientras tal protección no entre en conflicto con

la primera o segunda ley.

En 1954, George C. Devol, ingeniero norteamericano, estableció las bases del robot industrial moderno

al concebir la idea de un dispositivo de transferencia de artículos programada. En 1956, Devol y Joseph

F. Engelberger comenzaron a trabajar en la utilización industrial de sus máquinas y decidieron fundar

la primera compañía fabricante de robots, la Consolidated Controls Corporation, que más tarde se

Memoria

6

convirtió en Unimation (Universal Automation). En 1960, consiguieron instalar su primera máquina,

Unimate, en una aplicación de fundición por inyección en la fábrica de General Motors de Trenton,

Nueva Jersey.

Fig. 2.1. Robot Unimate [3].

El crecimiento de la robótica en Japón provocó la creación de la primera asociación de robótica del

mundo, la Asociación Robótica Industrial de Japón (JIRA) en el año 1972.

En 1973, ASEA construyó el primer robot con accionamiento totalmente eléctrico, el robot IRb6.

Además, en el mismo año, Victor Scheinman y Unimation desarrollaron un brazo robot industrial

llamado PUMA (Programmable Universal Machine for Assembly), comercializado como la máquina

universal programada para ensamblaje y siendo capaz de mover y orientar un objeto en cualquier

punto deseado que estuviera dentro de su alcance. La empresa KUKA también construyó su primer

robot, llamado FAMULUS, convirtiéndose en el primer robot articulado de 6 ejes impulsado electro-

mecánicamente.

Fig. 2.2. De izquierda a derecha: robot IRb6 [4], robot FAMULUS [5] y robot PUMA [6].


7

En 1981, el profesor Makino de la Universidad Yamanashi de Japón, desarrolla el concepto de robot

SCARA (Selective Compliance Assembly Robot Arm), que busca un robot con un número reducido de

grados de libertad (3 o 4), un coste limitado y una configuración orientada al ensamblado de piezas.

Fig. 2.3. Robot SCARA [7].

La evolución de los robots industriales ha sido exponencial, permitiendo la expansión de los robots por

varios tipos de industrias y en la mayoría de áreas productivas. Estos robots permiten sustituir al

humano en aquellas áreas repetitivas, y son capaces de adaptarse inmediatamente a los cambios de

producción solicitados.

2.1.2. Definición de robot industrial y clasificación

La robótica industrial se define como la disciplina destinada al estudio, diseño, realización y uso de

robots para la ejecución de procesos industriales. La Asociación de Industrias Robóticas (RIA) define el

robot industrial como un manipulador multifuncional reprogramable, capaz de mover materias, piezas,

herramientas o dispositivos especiales, según trayectorias variables, programadas para realizar tareas

diversas.

La Asociación Francesa de Robótica Industrial (AFRI) clasifica los robots en cuatro tipos [2]:

Tipo A: Manipulador con control manual o telemando.

Tipo B: Manipulador automático con ciclos preajustados, regulación mediante fines de carrera

o topes; control por PLC y accionamiento neumático, eléctrico o hidráulico.

Tipo C: Robot programable con trayectoria continua o punto a punto. Carece de conocimientos

sobre su entorno.

Tipo D: Robot capaz de adquirir datos de su entorno, readaptando su tarea en función de éstos.

Memoria

8

Otra manera de clasificar los robots industriales es a partir de las tres siguientes generaciones:

1ª Generación: Repite la tarea programada secuencialmente, sin tomar en cuenta las posibles

alteraciones de su entorno.

2ª Generación: Adquiere información limita de su entorno y actúa en consecuencia. Puede

localizar, clasificar (visión) y detectar esfuerzos y adaptar sus movimientos en consecuencia

3ª Generación: Su programación se realiza mediante el empleo de un lenguaje natural,

teniendo capacidad para la planificación automática de tareas.

Mecánicamente, un robot está formado por una serie de elementos unidos mediante articulaciones,

el movimiento de las cuales puede ser de desplazamiento, de giro o de una combinación de ambos.

Cada uno de los movimientos independientes que es capaz de realizar cada articulación se llama grado

de libertad (GDL) y se entiende que son necesarios 6 GDL para posicionar y orientar un cuerpo de

cualquier modo en el espacio.

2.1.3. Aplicaciones de la robótica industrial

En la actualidad los robots son utilizados mayormente en el sector industrial, siendo un elemento

necesario en la gran parte de procesos de manufactura, impulsados principalmente por el sector del

automóvil. A continuación, se detallan las principales tareas que realizan los robots en los principales

sectores de automatización industrial:

Fundición.

Soldadura.

Pintura y aplicación de adhesivos y sellantes.

Alimentación de máquinas.

Procesado.

Corte.

Paletización.

Control de calidad.

Manipulación en salas blancas.


9

2.2. La visión por computador

2.2.1. Definición de visión por computador y formación de imágenes

El concepto de visión por computador surge con la idea de que las máquinas sean capaces de imitar el

sistema de visión humano y, por lo tanto, puedan ver el mundo que las rodean. Concretamente, La

visión por computador o visión artificial se define como la rama de la inteligencia artificial que se

encarga de adquirir, procesar y analizar imágenes del mundo real con el objetivo de proporcionar

información que pueda ser tratada por una máquina.

Cualquier sistema de percepción visual, biológico o humano, tiene como punto de partida la imagen,

cuyo proceso de captación implica la utilización de algún tipo de sensor sobre el que se obtendrá la

representación bidimensional de la escena que aparece ante él.

En los seres vivos, el sistema de adquisición de imágenes lo constituyen los ojos, los cuales convierten

la información visual en impulsos nerviosos que son utilizados por el cerebro para interpretar dichas

imágenes. Básicamente, en este proceso de visión se ven involucrados tres agentes: la luz, el ojo y el

cerebro. La córnea y el cristalino proyectan de forma nítida las imágenes en la superficie de la retina,

actuando como lentes, seguidamente los fotorreceptores de la retina transforman la proyección en

impulsos nerviosos que el cerebro recibe mediante el nervio óptico.

Ahora bien, un sistema de visión artificial presenta muchas similitudes respecto al sistema de visión

humano. El iris del ojo se puede decir que es el diafragma de la cámara digital, la retina actúa como

sensor, y el cristalino realiza la función de la óptica, ya que se encarga de acercar o alejar la proyección

para conseguir un enfoque correcto. En la Figura 2.4. se muestran los sistemas de formación de

imágenes de un ojo humano y de un sistema de visión por computador [8].

Fig. 2.4. Sistema de formación de imágenes ojo humano - sistema de visión [8].

Memoria

10

2.2.2. Etapas del sistema de visión por computador

La visión por computador requiere de unas técnicas de procesamiento de imágenes para facilitar la

detección de regiones de interés en las imágenes y su propia localización. Básicamente, se llevan a

cabo cuatro actividades distintas para conseguirlo.

1) Captura y adquisición de la imagen: conjunto de operaciones que son efectuadas para

transformar la información luminosa de una escena en una imagen digital.

2) Pre-Procesamiento: conjunto de técnicas encargadas de realizar mejoras en la imagen digital

poder obtener información de ellas. Algunas de estas operaciones son la conversión a niveles

de gris, modificación del contraste, eliminación de ruido, transformaciones geométricas, etc.

3) Segmentación: proceso que divide la imagen en regiones donde los píxeles comparten algún

atributo, los objetos se extraen de la imagen para su posterior reconocimiento y análisis.

4) Extracción de características: consiste en extraer características de los objetos para obtener su

reconocimiento, como pueden ser formas o figuras que puedan relacionarse con patrones

externos.

Fig. 2.5. Etapas sistema de visión por computador.

2.2.3. La imagen digital y tipos de imágenes

Una imagen siempre está considerada como una representación continua de sombras y tonos (imagen

analógica), no obstante, para procesar automáticamente una imagen de este tipo en un ordenador, es

necesaria una transformación previa. La imagen continua de entrada ha de ser transformada a un

conjunto de números sobre los que pueda trabajar el ordenador, este proceso se conoce como

digitalización de la imagen e implica dos subprocesos. El primero de ellos se denomina muestreo y

básicamente realiza una subdivisión de la imagen analógica en porciones, el segundo se denomina

cuantificación y realiza una discretización de la amplitud del brillo en cada uno de estos puntos.

De esta manera, la imagen continua se representa mediante una matriz de dimensión N x M cuyos

elementos son cantidades discretas, formando lo que se denomina una imagen digital. Cada uno de

estos elementos se denomina píxel y se considera este como la menor unidad homogénea que forma

parte de la imagen digital.


11

En la Figura 2.6. se muestra una de las imágenes utilizadas en este proyecto, representando la imagen

digital como una matriz.

Fig. 2.6. Imagen digital expresada como matriz.

En este proyecto se va a proceder a utilizar tres tipos de imágenes principalmente:

Imagen a color: Los elementos de la matriz de la imagen tienen asociados tres valores de

intensidad, estos componentes son el rojo (R), verde (G) y azul (B) y es lo que se conoce como

el espacio de color RGB. En este caso se forma una matriz tridimensional, donde el elemento

(0,0,0) representa el color negro y el (255,255,255) es el blanco absoluto. Este espacio de color

tiene forma de cubo

Imagen en escala de grises: En este caso la matriz es bidimensional, donde cada uno de los

píxeles tiene un valor que representa su intensidad, en una escala entre el blanco y el negro,

es decir, teniendo como valores posibles aquellos entre 0 y 255. Normalmente, este valor se

obtiene mediante el promedio de los canales rojo, verde y azul (RGB):

I(x, y) = R(x,y)+G(x,y)+B(x,y)

3 (Ec. 1)

Imagen binarizada: Estas imágenes están formadas por sólo dos valores de intensidad, el 0 y

el 1, es decir, el blanco y el negro, de esta manera se reduce enormemente la cantidad de

datos y su posterior procesamiento se reduce al mínimo. El proceso de conversión de una

imagen en escala de grises a una binarizada se denomina binarización y básicamente lo que se

realiza es una transformación de todos los píxeles con niveles de gris igual o inferior a un cierto

umbral en negro puro y los que tengan un nivel de gris superior se convierten en blanco puro.

{B(i, j) = 0 si I(i, j) ≤ Umbral

B(i, j) = 1 si no. (Ec. 2)

Memoria

12

Fig. 2.7. Imagen a color, en escala de gris y binarizada.

2.2.4. Reconocimiento óptico de caracteres

Una de las aplicaciones actuales de la visión por computador más utilizadas es el reconocimiento óptico

de caracteres. Este reconocimiento óptico de caracteres, también llamado OCR (del inglés Optical

Chracter Recognition) es una tecnología de visión artificial mediante el cual el ordenador es capaz de

reconocer los dígitos contenidos en una imagen, obteniendo un archivo en un formato de texto.

Concretamente, el funcionamiento de un proceso OCR empieza por la inspección de la imagen pixel a

pixel, buscando formas que coincidan con los rasgos de caracteres. Seguidamente, el software busca

coincidencias de los caracteres detectados con los caracteres y fuentes disponibles, tratando de

identificarlos a través del análisis de sus características.

Un ejemplo de tecnología OCR en la actualidad es Tesseract, el cual fue desarrollado entre 1985 y 1994,

es de código abierto y es capaz de reconocer más de 100 idiomas.

Las aplicaciones de esta tecnología son muy variadas en la actualidad, entre las que destacan el

reconocimiento de caracteres manuscritos, el reconocimiento de matrículas y la indexación a bases de

datos.

2.3. Inteligencia artificial y Redes Neuronales Convolucionales (CNN)

2.3.1. La inteligencia artificial y el aprendizaje supervisado

Existen diversas definiciones para la inteligencia artificial (IA), sin embargo, se puede definir como el

área de la informática que, mediante la combinación de algoritmos, tiene el propósito de crear

máquinas que presenten las mismas capacidades que el ser humano, es decir, máquinas capaces de

realizar tareas características de la inteligencia humana.


13

El aprendizaje automático o aprendizaje máquina (del inglés Machine Learning) es la rama de la

inteligencia artificial que se encarga de desarrollar técnicas y algoritmos que permitan que las

computadoras aprendan y sean inteligentes, sin la necesidad de ser explícitamente programadas.

El aprendizaje supervisado es un tipo de aprendizaje automático donde se parte de un conjunto de

datos de entrenamiento previamente etiquetado y clasificado, es decir, se dispone de un conjunto de

datos en el que se conoce a qué grupo, valor o categoría pertenecen los ejemplos. A partir de este

grupo de datos denominado conjunto de entrenamiento se genera un modelo predictivo, de manera

que el algoritmo va “aprendiendo” a clasificar las muestras de entrada comparando el resultado del

modelo y la etiqueta real de la muestra. Algunos algoritmos de aprendizaje supervisado son los

siguientes:

K vecinos más cercanos (K-nearest neighbours).

Máquinas de soporte vectorial (Support Vector Machines).

Árboles de decisión (Decision Trees).

Clasificador Bayesiano (Naïve Bayes).

Redes neuronales artificiales (Artificial Neural Networks).

2.3.2. Redes neuronales artificiales y Deep Learning

Las redes neuronales artificiales son un algoritmo de aprendizaje automático basado en el

funcionamiento del cerebro humano. Concretamente, una neurona es la unidad funcional del sistema

nervioso y se encarga de recoger señales procedentes de otras neuronas a través de un conjunto de

estructuras llamadas dendritas, consiguiendo emitir impulsos de actividad eléctrica a lo largo de una

fina fibra denominada axón, el cual se divide en multitud de ramificaciones. La función de las neuronas

es la transmisión de impulsos nerviosos, desde las dendritas hasta las ramificaciones del axón, hasta

llegar a otra neurona mediante la conexión sináptica. La estructura principal de una neurona se puede

observar en la Figura 2.8.

Fig. 2.8. Imagen de una neurona [9].

La neurona artificial, o también llamada perceptrón, funciona de una manera similar, recibiendo una

serie de señales o datos de entrada y logrando obtener una salida como respuesta a los estímulos.

Memoria

14

Básicamente, cada una de las señales de entrada (xi) se multiplica por un peso aprendido (wi), llamado

peso sináptico, durante el proceso de entrenamiento denominado backpropagation y la neurona se

encarga de realizar la suma de estos productos, añadiéndole un parámetro también aprendido

denominado sesgo (b, del inglés bias). Este resultado finalmente se introduce en una función de

activación (f) que lo transforma a un valor de salida, obteniendo la salida neuronal Y mediante la

siguiente ecuación:

Y = f(∑ wixini=1 + b) (Ec. 3)

Cabe decir que existen distintas funciones de activación posibles en función del objetivo que tiene la

red neuronal, entre las más utilizadas se encuentran las funciones Relu, Softmax, Linear y Tanh.

En la Figura 2.9. se muestra de manera gráfica el funcionamiento de la neurona artificial.

Fig. 2.9. Modelo de una neurona artificial [9].

Una vez definida la neurona artificial básica, una red neuronal artificial consiste en una serie de

neuronas interconectadas entre sí, de manera que cada capa procesa la información recibida de la

anterior, hasta lograr una salida como resultado. De esta manera, y en función del número de capas y

la función de activación empleada, el sistema es capaz de resolver problemas de clasificación y

regresión con un nivel de complejidad mayor o menor.

Las redes neuronales con una capa oculta o intermedia se denominan Perceptrón Multicapa (en inglés

Multi-layer Perceptron). En la Figura 2.10. se representa una red con una sola capa oculta, con todas

las neuronas de una capa totalmente conectadas con las de la siguiente [8].


15

Fig. 2.10. Perceptrón multicapa [9].

Por otra parte, las redes neuronales con dos o más capas ocultas entre la entrada y la salida se

denominan redes profundas. Este tipo de redes constituyen lo que se llama Deep Learning (o

aprendizaje profundo en castellano) y logran obtener mejores resultados que las capas con una sola

capa oculta. En la Figura 2.11. se muestra una red profunda con una capa de entrada, tres capas ocultas

densamente conectadas y una capa de salida que se encarga de devolver la predicción obtenida.

Fig. 2.11. Red neuronal profunda (Deep Learning) [10].

Finalmente, se pueden encontrar multitud de redes neuronales en función de la tarea a resolver, entre

los que se encuentran las siguientes:

Redes Neuronales Convolucionales (CNN): imagen y vídeo.

Redes Neuronales Recurrentes (RNN): audio, lenguaje natural y series temporales.

Redes Generativas Antagónicas (GAN): generación de nuevos datos de entrada.

Autoencoders (AE): reducción de la dimensionalidad, cifrado.

Feed Forward (FF).

Redes de Función de Base Radial (RBF).

Memoria a largo/corto plazo (LSTM).

Cadenas de Markov (MC).

Memoria

16

Red Hopfield (RH).

Máquinas de Boltzmann (BM).

Redes de creencia profunda (DBN).

Redes desconvolucionales (DN).

2.3.3. Redes Neuronales Convolucionales (CNN)

Las redes neuronales convolucionales (CNN) son un tipo particular de redes neuronales que imita el

funcionamiento del córtex visual del ojo humano y tienen como tarea la resolución de problemas de

visión artificial. En este caso, la entrada a la red es una imagen definida en forma de matriz

tridimensional (ancho, alto y profundidad de color), de manera que las posiciones de la matriz

corresponden a los valores numéricos de los píxeles. Cabe decir que, si la imagen de entrada es en

color, entonces son necesarios tres canales distintos (red, green, blue) para el correcto reconocimiento.

El funcionamiento de este tipo de redes es bastante sencillo, las primeras capas de la red se encargan

de detectar formas y propiedades básicas y, a medida que llegan a capas más profundas, la red es capaz

de reconocer formas y características más complejas, como son caras y contornos. Gracias a este

procedimiento, las redes neuronales convolucionales presentan una serie de ventajas respecto a otros

métodos de inteligencia artificial, como es la detección de atributos en cualquier posición de la imagen

y la tolerancia ante variaciones de traslación, rotación y escalado.

Las redes CNN se construyen generalmente mediante la sucesión de tres tipos de capas

principalmente:

Capas Convolucionales: En estas capas las neuronas no están totalmente interconectadas,

dado que se utiliza el mismo filtro (los mismos pesos y el mismo sesgo) para todas las neuronas

de la capa oculta, reduciendo el número de conexiones y de parámetros en el entrenamiento.

Visualmente, se pueden considerar como una ventana que se va desplazando de izquierda a

derecha y de arriba abajo a través de la capa de entrada, formando una capa oculta cuyos

valores corresponden al producto escalar entre el filtro y la ventana.

En la Figura 2.12. se muestra una capa convolucional que recibe una imagen de tamaño 28x28

píxeles y utiliza 32 filtros de tamaño 5x5, generando un tensor 3D que contiene las 32 salidas

de 24x24 neuronas, resultado de computar los 32 filtros sobre la entrada.


17

Fig. 2.12. Capa convolucional con 64 filtros de tamaño 5x5 [10].

Capas de reducción (Pooling): Estas capas suelen ser aplicadas inmediatamente después de las

capas convolucionales y se encargan de hacer una simplificación de la información recibida,

creando una versión condensada de la información contenida en la capa convolucional y

reduciendo el número de parámetros a introducir en la siguiente capa. Esta simplificación se

realiza mediante una ventana a partir de dos métodos: Max pooling, que guarda el valor

máximo de los que están dentro de la ventana, y Average pooling, que guarda el valor medio.

En la Figura 2.13. se muestra una entrada de 4x4 píxeles y los resultados obtenidos al aplicar

los 2 métodos de pooling y una ventana de 2x2 píxeles.

Fig. 2.13. Capa de reducción (pooling) [10].

Capas totalmente conectadas (Fully Connected): Estas capas tienen la misma estructura que

un perceptrón multicapa y se utilizan al final de las capas de convolución y de reducción,

teniendo todas sus neuronas completamente conectadas.

Sin embargo, las redes neuronales convolucionales presentan un inconveniente principalmente, este

es la gran cantidad de imágenes necesarias para lograr la detección de las características únicas de cada

imagen y, a su vez, poder generalizarlo. Ante este problema, surgen los conceptos de subajuste

(underfitting) y sobreajuste (overfitting), problemas que han de ser solventados para que la red

Memoria

18

obtenga resultados correctos. Por una parte, si la red carece de suficientes datos de entrenamiento,

esta será incapaz de generalizar correctamente el conocimiento. Por otra parte, si la red realiza un

entrenamiento con imágenes demasiado específicas o es entrenada intensamente, esta se ajustará

para aprender solamente los casos particulares y será incapaz de reconocer nuevas imágenes de

entrada. Por eso mismo, es necesario establecer un equilibrio en el aprendizaje para no incurrir en

estos problemas, en la Figura 2.14. se muestran las gráficas posibles al realizar el entrenamiento de la

red.

Fig. 2.14. Entrenamiento con underfitting, correcto y con overfitting [11].

Las aplicaciones de las CNN son muy variadas en la actualidad, entre las que destacan el

reconocimiento de caracteres, diagnóstico y análisis médicos, reconocimiento de patrones, monitoreo

de aviones y diagnóstico de máquinas.


19

3. El sistema robot

En este tercer capítulo se procede a explicar el sistema del robot Mitsubishi con el cual se ha realizado

el proyecto, aportando una introducción a sus tres distintas partes:

Brazo robótico RV-2AJ.

Controlador CR1-571.

Consola de programación R28TB.

En la Figura 3.1. se puede observar el sistema robot localizado en el laboratorio.

Fig. 3.1. Sistema robot del proyecto.

3.1. Brazo robótico RV-2AJ

El brazo robótico utilizado para llevar a cabo la aplicación del proyecto es el robot RV-2AJ de Mitsubishi

Electric. Este robot tiene 5 grados de libertad y su diseño es ideal para aplicaciones con espacio

reducido y con movimiento de cargas de hasta 2 kg de masa. Tiene un alcance de 480 mm y combina

una velocidad máxima de 2200 mm/s con una repetibilidad de ± 0,02 mm.

Memoria

20

Fig. 3.2. Brazo robótico Mitsubishi RV-2AJ.

Los servomotores que utiliza son de corriente alterna, lo que garantiza una fiabilidad y un bajo

mantenimiento difíciles de superar por robots de estas características. Además, los encoders de

posición absoluta a los que están unidos los servomotores permiten que, al apagar el robot y

reconectarlo de nuevo, pueda continuar trabajando desde la posición actual.

Anteriormente se ha comentado que el brazo robótico tiene 5 grados de libertad; estos se denominan

J1, J2, J3, J5 y J6. Se puede observar que no existe J4, ya que este solamente está disponible en robots

de 6 grados de libertad. En la Figura 3.3. se puede encontrar una representación de cada eje.

Fig. 3.3. Ejes brazo robótico RV-2AJ [12].

Por otra parte, cabe destacar que el brazo robot tiene integrados una serie de conductos que permiten

la conexión de pinzas y ventosas neumáticas, incluyendo pinzas de accionamiento neumático. Además,

también es posible la adaptación de módulos de expansión para aumentar el número de grados de

libertad.


21

En la Tabla 3.1 se pueden observar las características técnicas más relevantes del brazo robótico.

Tabla 3.1. Características del brazo robótico RV-2AJ.

CARACTERÍSTICA ESPECIFICACIÓN

Modelo RV-2AJ

Grados de libertad 5

Instalación En suelo o en techo

Construcción Brazo articulado vertical

Sistema de accionamiento Servo AC (eje J1, J2, J3 y J5: con freno; eje

J6: sin freno)

Detección de posición Encoder de valor absoluto

Rango

de

movimientos

J1 300 (-150 , +150) grados

J2 180 (-60 , +120) grados

J3 230 (-110 , +120) grados

J5 180 (-90 , +90) grados

J6 400(-200 , +200) grados

Velocidad

de

movimiento

J1 180 grados/s

J2 90 grados/s

J3 135 grados/s

J5 180 grados/s

J6 210 grados/s

Repetibilidad de posicionamiento 0,02 mm

Velocidad máxima 2200 mm/s

Memoria

22

Capacidad

de carga

Nominal 1,5 kg

Máximo 2 kg

Temperatura ambiente De 0 ºC hasta 40 ºC

Radio de alcance 41 mm

Peso 17 kg

Momento nominal J5 2,16 N·m

J6 1,10 N·m

Momento de

inercia nominal

J5 3,24·10-2 kg·m2

J6 8,43·10-3 kg·m2

Se puede encontrar más información acerca del brazo robótico RV-2AJ en el manual del fabricante [13].

3.2. Controlador CR1-571

El controlador utilizado es el modelo CR1-571 y es el encargado del control del robot RV-2AJ,

permitiendo almacenar y ejecutar los programas en lenguaje MELFA BASIC IV realizados. Además, es

donde se conecta la consola de programación o botonera.

La base del controlador es una CPU de 64 bits que permite la ejecución de hasta 32 programas en modo

multitarea, siendo posible al mismo tiempo recibir datos, activar y desactivar entradas y salidas, realizar

cálculos, etc.

En la Figura 3.4. se puede observar el panel frontal del controlador y a continuación se procede a

explicar la función de cada uno de los botones, conectores y visualizador:


23

Fig. 3.4. Controlador CR2-571.

1. POWER: Interruptor para el encendido/apagado (ON/OFF)

2. START: Ejecuta el programa seleccionado y activa el robot. Una vez ejecutado el programa,

este corre continuamente hasta pulsar de nuevo.

3. STOP: Detiene el robot inmediatamente, aunque el servomotor no se detiene.

4. RESET: Restablece el estado de error o restablece el programa.

5. EMG.STOP: Detiene el robot ante un estado de emergencia. Al activar el botón, el servomotor

también se detiene.

6. REMOVE T/B: Botón para conectar/desconectar la teaching box sin necesidad de tener que

apagar la alimentación del controlador.

7. CHANG DISP: Cambia el contenido mostrado en el visualizador: Velocidad, Nº de programa,

Nº de línea.

8. END: Detiene el programa que se está ejecutando en la última línea.

9. SVO ON: Activa la alimentación del servomotor, permaneciendo un LED de color verde

encendido.

10. SVO OFF: Desactiva la alimentación del servomotor, permaneciendo un LED de color rojo

encendido.

11. STATUS NUMBER: Visualizador donde se muestra el número de error, número de programa,

valor de velocidad (%), etc.

12. CONEXIÓN TECHING BOX: Conector utilizado para conectar la teaching box.

13. CONEXIÓN PC: Conector utilizado para conectar un PC como emisor/receptor de datos de

especificación RS-232C.

14. MODE: Cambia el modo de operación del robot:

AUTO (Op): Únicamente las operaciones ordenadas por el controlador son válidas.

TEACH: Únicamente son válidas las operaciones ordenadas desde la teaching box.

Memoria

24

AUTO (Ext): El dispositivo externo, PC, es el único capaz de ordenar operaciones al

brazo robótico. Operaciones ordenadas por el controlador o la T/B no son válidas.

15. UP/DOWN: Se desplaza hacia arriba o hacia abajo por los contenidos del visualizador.

Se puede encontrar más información acerca del controlador CR1571 en el manual del fabricante [14].

3.3. Consola de programación R28TB

La consola de programación (o también botonera, teach pendant y teaching box) utilizada es el modelo

R28TB y es la encargada de la programación del brazo robótico.

En la Figura 3.5. se muestra el panel frontal de la consola y a continuación se describen las funciones

de cada uno de los botones y pulsadores de los que dispone:

Fig. 3.5. Consola de programación R28TB.

1. EMG. STOP: Se desactiva el servomotor y la operación de detiene inmediatamente.

2. T/B ENABLE/DISBLE: Llave que habilita/deshabilita la consola. Para que la consola esté

habilitada, el selector del modo del controlador ha de estar en la posición TEACH.

3. VISUALIZADOR LCD: Visualizador que muestra el estado del robot, valores de articulaciones,

posición del elemento terminal, etc.

4. SELECCIÓN JOG: Pulsadores de selección del modo de Jog.

JOINT: Control directo del movimiento de cada articulación.


25

XYZ: Control del movimiento del elemento terminal en las direcciones XYZ respecto

del sistema de referencia de la base del robot.

TOOL: Control del movimiento del elemento terminal en las direcciones XYZ respecto

del sistema de referencia de este mismo (pinza).

5. MENU: Devuelve la pantalla del visualizador al menú.

6. STOP: Detiene el programa y desacelera el robot hasta detenerlo.

7. STEP/MOVE: La operación de Jog se lleva a cabo cuando esta tecla se presiona

simultáneamente.

8. + FORWD: Incrementa el valor de velocidad.

9. - BACKWD: Disminuye el valor de velocidad.

10. COND: Establece el programa.

11. ERROR RESET: Restablece el error y libera el límite de software.

12. JOG OPERATION: Mueve el robot de acuerdo al modo de Jog seleccionado.

13. ADD: Registra los datos de posición o mueve el cursor hacia arriba.

14. RPL: Mueve el cursor hacia abajo.

15. DEL: Borra los datos de posición o mueve el cursor hacia la izquierda.

16. HAND: Abre y cierra la pinza o mueve el cursor hacia la derecha.

17. INP/EXE: Ingresa el programa y lleva a cabo la alimentación.

18. POS CHAR: Cambia la pantalla de edición y cambia entre números y caracteres alfabéticos.

19. DEADMAN SWITCH: Si ENABLE/DISABLE está habilitado, pulsador que cuando es soltado o

apretado con fuerza provoca la desactivación del servomotor y, por consecuencia, la

detención del robot.

Se puede encontrar más información acerca de la consola de programación R28TB en el manual del

fabricante [13].

Memoria

26

4. Herramientas utilizadas

En este capítulo se describen las distintas herramientas utilizadas para la realización de este proyecto.

Por una parte, se mencionan las herramientas empleadas en la programación del robot, haciendo una

breve explicación del lenguaje MELFA BASIC IV e introduciendo el programa RT Toolbox 2. Por otra

parte, se introduce el lenguaje Python y su entorno Spyder, comentando también las distintas librerías

utilizadas.

4.1. Programación del robot

4.1.1. El lenguaje MELFA BASIC IV

El lenguaje MELFA BASIC es el lenguaje de programación propio de los robots Mitsubishi e integra las

estructuras de control de flujo de BASIC con instrucciones específicas para el movimiento y el control

del robot [15]. Concretamente, el controlador CR1-571 soporta la versión MELFA BASIC IV.

La ejecución de toda la secuencia de instrucciones se define como ciclo y es obligatorio que la última

línea de programa contenga la instrucción END. Además, la ejecución del programa es continua, es

decir, al acabar de ejecutar un ciclo se inicia automáticamente otro. También es posible añadir

comentarios en las líneas de programa al añadir una apóstrofe (‘) al final de estas.

La estructura general de un programa MELFA BASIC IV es la siguiente:

Los principales tipos de variables en MELFA BASIC IV son las de posiciones y las numéricas. El nombre

de las variables numéricas debe de comenzar por M y el de las variables de posiciones han de comenzar

por P.

En este lenguaje existen distintos tipos de instrucciones según sean de control de movimiento o control

de programa. A continuación, se procede a detallar las instrucciones principales de MELFA BASIC IV:


27

4.1.1.1. Instrucciones de control de movimiento

Movimiento punto a punto (MOV): El extremo del robot se mueve desde la posición actual

hasta la indicada; la trayectoria descrita depende de la geometría del brazo y su control,

quedando fuera del control del usuario.

Movimiento lineal (MVS): El extremo del robot describe una línea recta entre su posición

actual y el destino especificado mediante interpolación lineal.

Movimiento circular:

o MVR: El extremo del robot describe un arco circular definido por tres puntos: punto

inicial, final e intermedio.

o MVR2: Se especifican punto inicial, final y uno tercero por el que no pasará. El arco

descrito es el complementario al que pasa por los puntos especificados.

Fig. 4.1. Movimiento punto a punto MOV.

Fig. 4.2. Movimiento lineal MVS.

Fig. 4.3. Movimiento circular MVR.

Memoria

28

Fig. 4.4. Movimiento circular MVR2.

o MVR3: Se especifican punto inicial, final y el centro del círculo. Se describe el arco que

supone el camino más corto entre inicio y fin.

Fig. 4.5. Movimiento circular MVR3.

o MVC: El extremo del robot describe círculos completos; se especifican el inicio, fin y

dos puntos de tránsito.

Movimiento continuo (CNT): Movimiento continuo pasando por diferentes puntos de paso,

permitiendo una mayor velocidad que con movimientos punto a punto.

Velocidad y aceleración:

o OVRD: Establece la velocidad de movimiento como un porcentaje de la velocidad

máxima.

o JOVRD: Establece un % respecto a la velocidad máxima para los movimientos

articulares.

o SPD: Establece la velocidad del extremo (mm/s) en movimientos lineales y circulares.

o ACCEL: Establece la aceleración y deceleración como un porcentaje respecto a la

máxima.

Fig. 4.6. Movimiento circular MVC.


29

Control de la pinza:

o HOPEN: Abre la pinza especificada.

o HCLOSE: Cierra la pinza especificada.

o TOOL: Permite definir la geometría de la pinza o herramienta, especificar donde está

su extremo respecto a la muñeca.

Paletizado:

o DEF PLT: Permite definir la ubicación y dimensiones de un palet.

o PLT: Obtiene la posición de un determinado compartimento del palet.

4.1.1.2. Instrucciones de control de programa

Saltos:

o GOTO: Salto incondicional a una línea de programa.

o ON GOTO: Salto en función del valor entero de una variable.

Condicionales:

o IF THEN ELSE: Condicional clásico, el comando ELSE es opcional.

o SELECT CASE: Condiciones múltiples respecto a una variable.

Fig. 4.7. Movimiento paletizado.

Memoria

30

Bucles:

o FOR NEXT: Ejecución controlada por contador (número fijo de iteraciones).

o WHILE WEND: Ejecución controlada por condición.

Programas y subprogramas

o GOSUB: Llamada a la subrutina.

o ON GOSUB: Llamada a diferentes subrutinas en función de una variable.

o RETURN: Retorno de subrutina al programa (siguiente instrucción a la de la llamada).

Espera, temporización y detención

o WAIT: Espera a que una señal alcance un determinado valor.

o DLY: Detención del programa o activación de una señal durante un tiempo

determinado (parámetro en segundos).

o HLT: Detiene el robot y la ejecución del programa. Tras su reactivación externa

(usuario) el programa continúa a partir de la siguiente instrucción.

o END: Define el fin de ciclo del programa. En ejecución continua, el programa vuelve a

ejecutarse desde la primera línea; en ejecución de un solo ciclo, el programa se

detiene tras el END.


31

Interrupciones

o DEF ACT: Define la interrupción, identificando el origen de la interrupción y la rutina

asociada.

o ACT: Habilita/inhabilita la atención de la interrupción.

o RETURN: Retorno al programa, a la instrucción interrumpida o a la siguiente.

4.1.1.3. Instrucciones de comunicaciones

El controlador del robot se puede comunicar mediante comunicación RS-232 con otros elementos,

siguiendo las siguientes instrucciones:

OPEN: Abre el canal de comunicación serie.

CLOSE: Cierra el canal de comunicación serie.

PRINT#: Escritura en el canal serie de datos en formato ASCII.

INPUT#: Lectura de datos del canal serie.

4.1.2. RT Toolbox 2

RT Toobox 2 es el entorno de programación para todos los robots de Mitsubishi, permitiendo crear

programas en los lenguajes MELFA BASIC IV, V y VI. El entorno permite la programación y la corrección

del programa del robot, la depuración del programa, la estimación del tiempo de ciclo, una marcha de

prueba mediante la función de simulación y, finalmente, la transferencia del programa creado al robot

mediante puerto serie.

Fig. 4.8. Logo RT Toolbox 2.

En la Figura 4.9. se muestra el programa RT Toolbox 2 utilizado, pudiendo observar tanto la ventana

de edición de programa como la ventana de simulación con el robot RV-2AJ.

Memoria

32

Fig. 4.9. Programa RT Toolbox 2.

4.2. Programación visión artificial PC

4.2.1. Python y Spyder

Python es un lenguaje de programación multiparadigma, dado que permite varios estilos de

programación: programación orientada a objetos, programación imperativa y programación funcional.

Además, se trata de un lenguaje interpretado, ya que no se compila a diferencia de otros lenguajes,

multiplataforma y dinámicamente tipado, debido a que una misma variable puede tomar valores de

distinto tipo en distintas situaciones. Es administrado por la Python Software Foundation y posee una

licencia de código abierto, pudiendo encontrar el código fuente en la página web de Python.

Por otra parte, el surgimiento de Big Data y la ciencia de datos, seguido de la explosión de la Inteligencia

Artificial, Machine Learning y Deep Learning han provocado un gran incremento en el uso de Python,

debido a que la mayoría de nuevas herramientas que han surgido han sido desarrolladas en Python u

ofrecen este lenguaje como forma para interactuar con ellas.

En concreto, se ha utilizado la versión de Python 3.6., la cual es compatible con todas las librerías

utilizadas en el proyecto.

Respecto a Spyder, se trata de un entorno de desarrollo integrado multiplataforma de código abierto

para programación científica en lenguaje Python. Se integra con una serie de paquetes que serán

utilizados en este proyecto como son NumPy, SciPy, Matplotlib y Pandas. Concretamente, se ha

utilizado la versión Spyder 4, compatible con Python 3.6.


33

Fig. 4.10. Logos Python y Spyder.

4.2.2. OpenCV

OpenCV (Open Souce Computer Vision Library) es una biblioteca libre de visión por computador

desarrollada por Intel que, desde su lanzamiento en el año 2000, ha sido utilizada en multitud de

aplicaciones, desde el reconocimiento de objetos hasta detección de movimiento en tiempo real.

Está escrita en C++ y es multiplataforma, pudiendo ejecutarse en distintos sistemas operativos como

Windows, Linux, MAC OS X, Android e iOS. Además, cuenta con interfaces que permiten trabajar con

lenguajes como Java, Python y MATLAB.

Fig. 4.11. Logo OpenCV.

4.2.3. TensorFlow

TensorFlow es una biblioteca de código abierto para computación numérica, que utiliza grafos de flujo

de datos. Los nodos en las gráficas representan operaciones matemáticas, mientras que los bordes

representan las matrices de datos multidimensionales (tensores) comunicadas entre ellas.

Fue desarrollado originalmente por investigadores e ingenieros que trabajan en el equipo de Google

Brain Team, con el propósito de realizar investigaciones de aprendizaje automático y redes neuronales,

aunque se le considera lo suficientemente general para ser aplicable en una amplia variedad de

dominios. TensorFlow fue liberado como software de código abierto en noviembre de 2015 y está

disponible en Windows, Linux, MAC OS, Android e iOS.

Esta plataforma open-source de Google se ha posicionado como la herramienta líder en el sector de

aprendizaje profundo (Deep Learning) gracias a su flexibilidad y gran comunidad de desarrolladores.

Además, es compatible con las versiones de Python entre la 3.5. y la 3.7.

Memoria

34

Fig. 4.12. Logo TensorFlow.

4.2.4. Keras

Keras es una biblioteca de código abierto escrita en Python destinada a redes neuronales y capaz de

ejecutarse sobre TensorFlow, Microsoft Cognitive Toolkit o Theano. Está especialmente diseñada para

posibilitar la rápida experimentación con redes de aprendizaje profundo y persigue ser amigable para

el usuario, modular y de fácil extensibilidad.

Esta biblioteca soporta tanto redes neuronales convolucionales como recurrentes, así como la

combinación de ambas. Además, permite la ejecución tanto en CPU como en GPU y tiene un gran

acoplamiento con Python, dado que soporta las versiones desde 2.7 hasta 3.6.

Fig. 4.13. Logo Keras.

4.2.5. Scikit-learn

Scikit-learn es una biblioteca libre para aprendizaje máquina desarrollada inicialmente por David

Cournapeau en 2007 y está escrita principalmente en Python.

Incluye varios algoritmos de clasificación, regresión y análisis de grupos entre los que se encuentran

máquinas de soporte vectorial (SVM), árboles de decisión (Decision Trees), K-vecinos más cercanos

(KNN), Gradient Boosting, K-means, etc.

Fig. 4.14. Logo Scikit-learn.


35

4.2.6. Pandas

Pandas es una biblioteca del lenguaje de programación Python destinada a la manipulación y análisis

de datos (Data Science). Ofrece estructuras de datos y operaciones para la manipulación de tablas

numéricas y series temporales. Entre otras funciones, permite la inserción y unión de columnas en

conjuntos de datos, mezcla y segmentación de datos.

Fig. 4.15. Logo Pandas.

4.2.7. Tkinter

Tkinter es una adaptación de la biblioteca gráfica Tcl/Tk para el lenguaje de programación Python. Esta

librería permite la realización de interfaces gráficas de usuario (GUI) a partir de las distintas funciones

que incluye.

Fig. 4.16. Logo Tcl/Tk.

Memoria

36

5. Diseño de piezas y espacio de trabajo

En este quinto capítulo del documento se presenta el trabajo previo realizado para la determinación

del número de piezas para la aplicación y su posterior diseño, además del estudio del espacio de trabajo

y la correcta ubicación de la cámara.

5.1. Determinación del número de piezas

Con el objetivo de establecer la distribución de letras y cubos necesarios para el desarrollo de la

aplicación demostrativa, ha sido necesaria la búsqueda de la frecuencia de aparición relativa de cada

una de las letras del abecedario, además de los nombres más comunes en España.

Primeramente, se ha recurrido a una gráfica que muestra la frecuencia de aparición relativa de cada

letra en las palabras españolas, como se puede observar en la Figura 5.1.

Fig. 5.1. Frecuencia relativa de letras [16].

Observando la gráfica se puede comprobar que las letras que más veces aparecen en palabras en

español son las letras A, E, O, S y R, por lo tanto, es necesaria la disponibilidad de una cantidad mayor

de cubos que contengan estas letras. En cambio, las letras Z, Ñ, X, K y W tienen una frecuencia de

aparición muy pequeña, por lo que no es necesario tener una gran cantidad de estas letras en la

aplicación.


37

Seguidamente, siguiendo el orden del abecedario, ha sido fijada la distribución de las distintas letras

en los cubos, formando así cinco grupos de cubos, según las letras adhesivas que tienen en sus caras:

Grupo I: contienen las letras A, B, C, D, E y F del abecedario.

Grupo II: contienen las letras G, H, I, J, K y L del abecedario.

Grupo III: contienen las letras M, N, O, P, Q y R del abecedario.

Grupo IV: contienen las letras S, T, U, V, W y X del abecedario.

Grupo V: contienen las letras Y y Z del abecedario. Además, se añaden las letras A, E, O y S para

disminuir la cantidad de cubos necesarios de los otros grupos.

Una vez fijada la distribución, se debe realizar un estudio para la determinación del número de cubos

necesarios para formar la mayor cantidad de nombres en la aplicación demostrativa. Para eso, se han

utilizado los nombres más comunes para observar cuantos cubos de cada grupo, siguiendo la

distribución fijada, son necesarios para formarlos. Algunos de estos nombres consultados y la

distribución de cubos para su formación se recogen en la Tabla 5.1.

Tabla 5.1. Nombres y números de cubos.

Nombre Cubos necesarios Nombre Cubos necesarios

ÁNGEL 2 x I + 2 x II + 1 x III MERCEDES 3 x I + 2 x III + 1 x IV + 2 x V

SEBASTIÁN 3 x I + 1 x II + 1 x III + 2·IV + 2 x V MÓNICA 2 x I + 1 x II + 3 x III

GERARD 3 x I + 1 x II + 2 x III DANIEL 3 x I + 2 x II + 1 x III

ANTONIO 1 x I + 1 x II + 3 x III + 1 x IV + 1 x V CARLOS 2 x I + 1 x II + 2 x III + 1 x IV

NURIA 1 x I + 1 x II + 2 x III + 1 x IV RAQUEL 2 x I + 1 x II + 2 x III + 1 x IV

MANUELA 3 x I + 1 x II + 2 x III + 1 x IV DOLORES 2 x I + 1 x II + 3 x III 1 x IV

ANDREA 3 x I + 2 x III + 1 x IV LAURA 2 x I + 1 x II + 1 x III + 1 x IV

CHRISTIAN 2 x I + 3 x II + 2 x III + 2 x IV DAVID 3 x I + 1 x II + 1 x IV

JESSICA 3 x I + 2 x II + 2 x IV MARTINA 2 x I + 1 x II + 3 x III + 1 x IV

ENRIQUE 2 x I + 1 x II + 3 x III + 1 x IV YAIZA 2 x I + 1 x II + 2 x V

Memoria

38

FRANCISCO 3 x I + 1 x II + 3 x III + 1 x IV + 1 x V IRENE 2 x I + 1 x II + 2 x III

ALEJANDRA 3 x I + 2 x II + 2 x III + 2 x V MARIO 1 x I + 1 x II + 2 x III

A partir de los resultados obtenidos en el estudio y persiguiendo en todo momento la menor cantidad

de cubos necesarios, se establece que el número de cubos mínimo para llevar a cabo la aplicación y

formar la mayor cantidad de nombres son 13 en total: 3 del grupo I, 3 de grupo II, 3 del grupo III, 2 del

grupo IV y 2 del grupo V.

5.2. Diseño de piezas

Los cubos que se han utilizado para el desarrollo del proyecto han sido unos de los que se disponía en

el laboratorio de automática. Inicialmente, se ha comprobado que el tamaño de estos cubos permita

al brazo robótico recogerlos correctamente mediante la pinza eléctrica que lleva instalada,

construyendo el nombre deseado. Además, se ha optado por realizar una prueba de visualización con

la cámara disponible con el fin de comprobar que estos cubos puedan ser vistos fácilmente.

En la Figura 5.2 se puede observar el estado inicial de los cubos escogidos, cuyo material es la madera

y miden 4 cm de lado.

Fig. 5.2. Estado inicial de las piezas utilizadas.

Seguidamente, se procede a pintar cada una de estas piezas de madera de color blanco, debido a que

se cree que es un color que puede ser visto con claridad por la cámara. Finalmente, como en cada una

de las caras de estos cubos ha de haber una letra del abecedario, se opta por colocar unos adhesivos

de letras de color negro en cada una de estas caras, como los que se pueden ver en la Figura 5.3.


39

Fig. 5.3. Letras adhesivas utilizadas en la aplicación.

Se puede ver el estado final de los cubos que se utilizan en la aplicación, una vez pintados de color

blanco y enganchando las letras adhesivas, en la figura 5.4.

Fig. 5.4. Estado final de las piezas utilizadas.

5.3. Espacio de trabajo

El espacio de trabajo utilizado en la realización del proyecto está situado en el laboratorio de robótica

de la Escuela de Ingeniería de Barcelona Este (EEBE). Concretamente, se emplea una mesa de

dimensiones 1280x720 cm como tablero, el cual ha sido dividido en tres zonas para llevar a cabo la

aplicación demostrativa:

Zona Roja: Es la zona donde se sitúa un contenedor para que el usuario recoja las piezas

necesarias para la formación de su nombre.

Memoria

40

Zona azul: Es la zona donde se coloca un soporte de metacrilato para que el robot proceda a

colocar las letras que ha recogido del tablero en el orden correcto para formar el nombre del

usuario. El soporte utilizado es el de la Figura 5.5.

Fig. 5.5. Soporte para la colocación de letras.

Zona Negra: Es la zona donde, una vez el usuario ha seleccionado las piezas necesarias, las

coloca libremente para que el robot las reconozca e identifique su posición y orientación. Se

decide colocar una cartulina negra en esta zona con el motivo de facilitar el procesado de la

imagen capturada por la cámara y, así, evitar posibles errores ante distintos entornos de

iluminación.

En la figura 5.6 se observa la disposición de estas tres zonas en el tablero.

Fig. 5.6. Partes del tablero de la aplicación.

5.4. Ubicación de la cámara

La cámara utilizada en el proyecto es el modelo VF0700 Live de la marca Creative, una cámara de alta

definición que permite minimizar el ruido existente al capturar una imagen, obteniendo estas

imágenes en una mayor resolución. En la siguiente imagen se puede visualizar la cámara Live Creative

utilizada:


41

Fig. 5.7. Cámara Creative Live.

Respecto a la ubicación de la cámara dentro del espacio de trabajo, es necesario que esté posicionada

a una altura lo suficientemente alta para hacer posible la captación de imágenes donde sea posible

observar todas las piezas situadas dentro de la zona negra de la aplicación. Además, esta ubicación ha

de ser lo más paralela a la mesa con el objetivo de capturar solamente la letra situada en el lado

superior de las distintas piezas ubicadas en el espacio de trabajo, que es la que se va a tratar de

reconocer y colocar en todo momento.

Por otra parte, la ubicación de la cámara ha de ser lo más estática posible, es decir, se ha de tener

cuidado en mover lo menos posible la cámara de su posición fijada. Esto es debido a que los algoritmos

de visión e inteligencia artificial utilizados en el proyecto pueden fallar al variar la ubicación.

A causa de las características mencionadas en la ubicación de la cámara, se ha decidido colocarla en un

soporte que proporcione su máxima altura y que impida la colisión en todo momento con el robot. A

continuación, en la Figura 5.8. se muestra una imagen del entorno de la aplicación con la cámara

situada en el soporte.

Fig. 5.8. Localización de la cámara en el soporte.

Memoria

42

6. Extracción y localización de regiones de interés (ROIs)

En este capítulo se procede a explicar los distintos procesos realizados con el objetivo de llevar a cabo

la detección y extracción de las regiones de interés (ROIs) de la imagen capturada, pasando por la

conversión a escala de grises de la imagen y su posterior binarización para la correcta detección de

contornos. Por otra parte, se explica el procedimiento realizado para la identificación de los centroides

de estos contornos de la imagen y el experimento de regresión llevado a cabo con el fin de transformar

sus coordenadas en píxeles a coordenadas reales, aptas para el brazo robótico.

6.1. Detección y extracción de regiones de interés (ROIs)

Con el fin de detectar y extraer los distintos contornos de la imagen tomada por la cámara, la librería

OpenCV de Python proporciona distintas funciones para la realización esta tarea. Básicamente, el

procedimiento a seguir para la búsqueda de contornos en una imagen son los siguientes:

Conversión de la imagen a escala de grises.

Filtrado de la imagen para reducir el ruido.

Binarización de la imagen.

Búsqueda de contornos.

Extracción de regiones de interés (ROIs)

6.1.1. Conversión de la imagen a escala de grises

La conversión a escala de grises de la imagen que se desea procesar se realiza debido a dos motivos

principalmente. Por una parte, si por ejemplo se tiene una imagen con tres canales de color como es

en el espacio RGB (Red Green Blue), es como si se estuviera trabajando realmente con tres imágenes,

una para cada componente; por eso mismo, y para reducir el coste computacional, se realiza una

conversión a escala de grises de la imagen. Por otra parte, con el objetivo de llevar a cabo la detección

de contornos en la imagen, esta conversión a escala de grises es un requisito con la librería utilizada.

En este caso, un ejemplo de imagen que puede ser obtenida por la cámara y que, por lo tanto, se desea

procesar, es la siguiente:


43

Fig. 6.1. Imagen original capturada por la cámara.

La zona negra que se puede observar en la imagen es el lugar donde se han de poner los distintos cubos

a la hora de llevar a cabo la aplicación demostrativa y, por lo tanto, la zona de interés a la hora de

realizar el preproceso. Cabe decir que la cámara se podría haber situado para capturar solamente esta

zona, sin embargo, esta posición podría ocasionar la colisión del brazo robótico con el soporte de la

cámara al no tener suficiente altura y, por lo tanto, se ha descartado esta opción. Para obtener

solamente la zona negra se ha realizado un recorte de la imagen original mediante Python como paso

previo a la conversión a escala de grises, obteniendo el resultado de la Figura 6.2.

Fig. 6.2. Imagen recortada.

Una vez recortada la imagen, se procede a realizar la conversión a escala de grises. La función

“cvtColor” de OpenCV es la encargada de realizar la conversión de la imagen entre espacios de color.

Esta función tiene 2 parámetros, el primero de ellos es la imagen que se desea convertir y el segundo

es el tipo de conversión, es decir, de que espacio a que espacio se realiza la conversión. En este caso,

dado que se desea convertir la imagen original del espacio RGB al espacio en escala de grises, el

segundo parámetro será cv2.COLOR_BGR2GRAY. Además, es posible ver la imagen obtenida como

Memoria

44

resultado mediante la función “imshow”. El código utilizado para el recorte y la conversión a escala de

grises es el siguiente, en este ejemplo leyendo una imagen ya capturada:

En la Figura 6.3 se observa el resultado que se obtiene al realizar la conversión con el código anterior.

Fig. 6.3. Imagen en escala de grises.

6.1.2. Filtrado de la imagen para reducir el ruido

Una vez que la imagen ha sido convertida a escala de grises, el siguiente paso es la eliminación del

ruido existente, una técnica que se conoce como suavizado. Para eliminar este ruido de la imagen

existen distintos filtros, lineales y no lineales, entre los que destacan el filtro de la media, el Gaussiano

y el filtro de la mediana.

Estos filtros de suavizado eliminan el ruido caracterizado por su alta frecuencia espacial aplicando una

máscara llamada Kernel, de tamaño N x N por los píxeles de la imagen. Sin embargo, esto tiene un

efecto negativo que consiste en hacer la imagen más borrosa, reduciendo sus detalles y, por este

motivo, el tamaño y valores de la máscara han de ser escogidos teniendo en cuenta el compromiso

entre reducción del ruido y degradación de la imagen.


45

En este caso, se procede a utilizar el filtro Gaussiano para eliminar el ruido existente en la imagen en

escala de grises, caracterizado por aportar menos peso a medida que los píxeles están más alejados

del centro de la máscara. La librería OpenCV tiene una función llamada “GaussianBlur” que se encarga

de implementar este filtro a partir de tres parámetros. El primer parámetro es la imagen que se desea

suavizar, el segundo consiste en la altura y el ancho del Kernel (N x N, debe ser positivo e impar) y el

último parámetro es la desviación estándar, Ơ, de la función Gaussiana y permite modular la intensidad

del suavizado, es decir, un valor más elevado provoca un efecto de suavizado mayor.

En el caso de la imagen en escala de grises obtenida en el apartado anterior, se ha decidido aplicar un

Kernel de 5x5 y un valor 0 al último parámetro, valor mediante el cual OpenCV se encarga de aplicar el

valor de desviación estándar más adecuado. El código Python utilizado es el siguiente, de manera que

se obtiene la imagen de la Figura 6.4.

Fig. 6.4. Imagen en escala de grises con filtro Gaussiano.

6.1.3. Binarización de la imagen

La binarización se conoce como el proceso de conversión de una imagen en escala de grises a una

imagen formada sólo por dos valores de intensidad, 0 y 1. Este proceso consiste en transformar en

negro puro todos los píxeles con niveles de gris inferior o igual a un determinado nivel de gris,

denominado umbral de binarización, y en blanco puro los que tengan un nivel de gris superior.

La determinación del umbral idóneo se obtiene utilizando el histograma de la imagen, este será el que

mejor divida los niveles de gris en dos poblaciones bien diferenciadas, es decir, el valle del histograma.

En el caso de la imagen en escala de gris obtenida en el apartado anterior, su histograma es el que se

muestra en la Figura 6.5.

Memoria

46

Fig. 6.5. Histograma imagen en escala de grises.

OpenCV permite aplicar la binarización mediante la función “threshold”, la cual dispone de cuatro

parámetros. El primero de ellos es la imagen que se desea umbralizar, el segundo se corresponde con

el umbral definido, el tercero consiste en el valor máximo que se establece a un píxel si el umbral es

superado y el cuarto parámetro consiste en el tipo de umbralización que se desea realizar, en este caso

binaria.

A continuación, se muestran las imágenes obtenidas como resultado al realizar la binarización con

valores de umbral de 100, 150, 200 y 250.

Fig. 6.6. Imágenes binarizadas con valor de umbral 100, 150, 200 y 250.

Se puede comprobar que, a medida que en el caso de valor de umbral 100 (izquierda arriba), se

detectan también algunas de las caras no frontales de las piezas cúbicas, pudiendo causar problemas

a la hora de llevar a cabo la detección de contornos. A medida que se aumenta este valor, la


47

binarización convierte una mayor cantidad de píxeles a negro y, a partir de un valor umbral de 200, se

logra aislar solamente la cara frontal de cada uno de los cubos.

Por otra parte, OpenCV también permite realizar la binarización de Otsu sobre las imágenes, de manera

que se calcula de forma automática un valor umbral óptimo mediante el histograma de la imagen. Este

método requiere que la imagen sea bimodal, es decir, que su histograma contenga dos picos para

obtener el valor de umbral como un valor medio entre estos picos.

La imagen binarizada obtenida como resultado de aplicar la binarización de Otsu sobre la imagen en

escala de grises capturada por la cámara es la de la Figura 6.7, obteniendo un valor de umbral de

binarización de 134.

Fig. 6.7. Imagen binarizada mediante binarización de Otsu.

Sin embargo, se puede observar que esta imagen binarizada no aporta una solución óptima, debido a

que existen más píxeles en blanco que en el caso de un umbral de 200, siendo esta última la que mejor

detecta las caras de las piezas cúbicas capturadas por la cámara. De esta manera, se decide utilizar un

valor de umbral igual a 200, siendo el código utilizado para obtener la imagen binarizada el siguiente:

En este caso, “imgGauss” es la imagen filtrada previamente, “cv2.THRESH_BINARY” significa que se

trata de una binarización, 200 es el valor de umbral escogido, y 255 es el valor al que se transforman

los píxeles con valor superior al umbral.

Memoria

48

6.1.4. Búsqueda de contornos

Una vez binarizada la imagen capturada por la cámara, en este apartado se procede a detectar los

distintos contornos que se observan en ella, los cuales coinciden con las piezas cúbicas que contienen

las letras que se desean extraer.

Un contorno es una curva o una línea de puntos sin huecos ni saltos, es decir, donde el principio y el

final es el mismo punto. La primera opción que se ha procedido a realizar es la detección directa de los

contornos de las letras, sin embargo, en los casos en que las letras están rotadas, los contornos

detectados para cada letra tienen distintos tamaños y, además, no coinciden exactamente con la

rotación real, pudiendo ocasionar resultados erróneos posteriormente. Por este motivo, los contornos

que se desean obtener de la imagen binarizada son los pertenecientes a los distintos cubos de la

imagen, sin tener en cuenta las letras que tienen en su interior, de manera que se obtengan unos

contornos de tamaños muy similares.

Para poder encontrar los contornos de los cuadrados, OpenCV ofrece una función llamada

“findContours” que se encarga de realizar esta tarea a partir de tres parámetros:

1. Imagen binarizada de la que se desea obtener los contornos.

2. Indica el tipo de contorno que se quiere, pudiendo tener distintos valores: RETR_EXTERNAL,

RETR_LIST Y RETRN_TREE. En este caso, la opción utilizada es RETR_EXTERNAL, dado que se

procede a utilizar el contorno externo de los cubos para delimitar la imagen de las letras

contenidas.

3. Indica el tipo de aproximación del contorno. Básicamente se diferencia entre

CHAIN_APPROX_NONE y CHAIN_APPROX_SIMPLE. La primera de ellas conserva todos los

puntos del contorno y la segunda se encarga de eliminar los puntos redundantes.

Además, con OpenCV es posible dibujar estos contornos sobre la imagen mediante la función

“drawContours”, la cual contiene cinco parámetros:

1. Imagen donde se dibujan los contornos, en este caso sobre la imagen original.

2. Lista de Python con los contornos encontrados.

3. Número de contornos que se desea dibujar, si se desea dibujar todos poner el valor -1.

4. Array o tupla con el color RGB del contorno, en este caso en color rojo.

5. Grosor de la línea a dibujar como contorno.

Con el objetivo de reconocer solamente como contornos las piezas cúbicas en la imagen y obviar

contornos no deseados en la imagen, se ha utilizado la función “contourArea” para calcular el área de

cada contorno detectado y solo guardar aquellos que tengan un área comprendida entre 100 y 2000.


49

El código para la obtención de los cuadrados detectados en la imagen binarizada es el siguiente, donde

se dibujan en color rojo los distintos contornos sobre la imagen recortada y se imprime el número total.

En la Figura 6.8. se muestra la imagen resultante al ejecutar el código para la obtención de los

contornos.

Fig. 6.8. Detección de contornos de la imagen.

6.1.5. Extracción de regiones de interés (ROIs)

Por último, es necesario realizar la extracción de las distintas regiones de interés (ROIs) detectadas en

la imagen para que sean reconocidas individualmente mediante la red CNN de reconocimiento de

letras.

Memoria

50

Básicamente, el procedimiento utilizado para la extracción de las ROIs de la imagen y su adaptación

para poder ser analizadas por la red CNN es el siguiente:

1. Se extrae la zona delimitada por el rectángulo del contorno generado por la función

“boundingRect” de la imagen en escala de grises y filtrada. Se reduce esta zona un margen de

3 píxeles a cada lado con el objetivo de evitar que aparezcan zonas no deseadas en la imagen,

como pueden ser las letras situadas en los lados contiguos del cubo.

2. Mediante la función “copyMakeBorder” de OpenCV, se añade un borde de color blanco

(255,255,255) de 2 píxeles de ancho para que la letra contenida aparezca centrada.

3. La imagen resultante es binarizada mediante la función “threshold” con un umbral de

binarización de 170, valor óptimo encontrado al realizar distintas pruebas en el

reconocimiento de estas ROIs.

4. Finalmente, la imagen de la ROI se redimensiona a 32x32 píxeles, adecuándola a la entrada de

la red neuronal entrenada.

Para guardar las imágenes de los distintos recortes se crea una lista llamada “ROI”, en cuyas posiciones

se guardan las regiones de interés ya preprocesadas y preparadas para ser reconocidas. El código

creado es el siguiente, siendo necesario añadirlo dentro del bucle “for c in contours” utilizado en el

apartado anterior.

En la Figura 6.9. se representan finalmente las ROIs encontradas en la imagen original, como se puede

observar ya binarizadas y con tamaño 32x32 píxeles.

Fig. 6.9. Regiones de interés de la imagen.


51

6.2. Transformación de coordenadas

Una vez detectadas las distintas regiones de interés en la imagen capturada por la cámara, es necesario

conocer sus respectivas coordenadas en píxeles y transformarlas a coordenadas reales en milímetros

(mm) para que el robot pueda ir a recogerlas y girarlas para situarlas correctamente para la formación

del nombre.

Para resolver esta transformación se ha decidido llevar a cabo una regresión mediante algoritmos de

Machine Learning de las coordenadas en píxeles hasta obtener las coordenadas reales, de manera que

el problema se puede dividir en dos partes diferenciadas:

Búsqueda del centro de las ROIs de la imagen.

Experimento de regresión de las coordenadas reales.

6.2.1. Búsqueda del centro de las ROIs en la imagen

Primeramente, es necesaria la obtención de las coordenadas del centro (en píxeles) de cada región

detectada en la imagen. Para lograrlo, se procede a utilizar los momentos de cada uno de los contornos.

Estos momentos se definen por la siguiente ecuación, donde la función I(x,y) indica su intensidad:

Mij = ∑ ∑ xiyjI(x, y)

yx

(Ec. 4)

Para encontrar el centro de masas es necesaria la definición de tres momentos [20], donde la función

intensidad solamente puede tomar los valores 0 y 1, al ser una imagen binarizada.

M00: Número de píxeles cuya intensidad vale 1 (región blanca).

M00 = ∑ ∑ x0y0I(x, y) = I(x, y)

yx

(Ec. 5)

M10: Suma de las coordenadas “x” de los píxeles cuya intensidad es 1.

M10 = ∑ ∑ x1y0I(x, y) = x · I(x, y)

yx

(Ec. 6)

M01: Suma de las coordenadas “y” de los píxeles cuya intensidad es 1.

Memoria

52

M01 = ∑ ∑ x0y1I(x, y) = y · I(x, y)

yx

(Ec. 7)

Por lo tanto, el centroide de la componente x se puede obtener dividiendo el momento M10 por el

momento M00:

x̅ = M10

M00=

x1+x2+⋯+xn

n (Ec.8)

Y para obtener el centroide de la componente y se divide el momento M01 por el momento M00:

y̅ = M01

M00=

y1+y2+⋯+yn

n (Ec. 9)

Para el cálculo de los tres momentos, OpenCV ofrece la función “moments”, de manera que se crea un

código donde se puede observar el cálculo del centroide de cada contorno, dibujando en la imagen su

centro y, además, escribiendo las coordenadas de este. Cabe decir que se crean dos listas, “centroX” y

“centroY”, donde se van guardando las coordenadas x e y de los centroides de todas las ROIs.

De esta manera, se obtiene como resultado las listas siguientes y la imagen de la Figura 6.10.

Fig. 6.10. Centroides (píxeles) de la imagen.


53

6.2.2. Experimento de regresión de las coordenadas reales

Una vez reconocidas el centro de cada ROI en la imagen, es necesario transformar la localización del

centroide respecto al sistema de referencia de la imagen en la localización correspondiente del centro

del cubo respecto al sistema de referencia del robot, posición que es utilizada por este para realizar

sus movimientos.

Para llevar a cabo esta transformación del sistema de coordenadas, se ha decidido realizar un problema

de regresión que tiene como entradas las dos coordenadas en píxeles de la imagen y como salidas las

coordenadas reales del robot. Este problema se procede a afrontar en dos partes, las cuales se

describen a continuación:

Creación del conjunto de datos de entrenamiento

Regresión de las coordenadas reales de la imagen

De esta manera, se procede a diseñar un conjunto de datos lo suficientemente amplio (100 muestras)

para que, introduciéndolo en un algoritmo de regresión como muestras de entrenamiento, crear un

modelo que sea finalmente capaz de dar una predicción de coordenadas reales a nuevos ejemplos.

Básicamente, en la Figura 6.11. se resume lo que se pretende desarrollar para la transformación de

sistemas de coordenadas. El conjunto de datos diseñado se denomina data, que se utiliza para el

aprendizaje de un modelo de regresión para luego dar una predicción a nuevos ejemplos no vistos

anteriormente.

Fig. 6.11. Proceso de aprendizaje para la regresión de coordenadas.

6.2.2.1. Creación del conjunto de datos de entrenamiento

La primera parte del problema que se ha de realizar es la creación de un conjunto de datos válido para

el entrenamiento de un algoritmo de regresión que sea capaz de, introducidas las coordenadas en

píxeles de las piezas, devuelva unas coordenadas reales de las piezas que sean entendibles por el robot.

Memoria

54

Con este objetivo, se procede a crear un conjunto de datos a partir de un método experimental.

Primeramente, se realiza una captura con la cámara de una imagen en la que se observa solamente

una de las piezas cúbicas, en estos momentos no importa la letra que se observa, ya que lo único que

interesa para este proceso es el centroide (x, y) de la pieza en píxeles. Seguidamente, se procede a

mover el extremo del brazo robótico de forma manual hasta el lugar donde se encuentra la pieza, con

el objetivo de obtener, desde la consola de programación, las coordenadas del extremo (x’, y’),

respecto la base del robot, cuando se sitúa sobre la pieza.

Para acabar, se crea una tabla con las coordenadas de entrada en píxeles (CentroX, CentroY) y con las

coordenadas de salida en mm (X, Y) para todas las posiciones anotadas, como se puede observar en la

Tabla 6.1.

Tabla 6.1. Tabla con los 10 primeros datos de regresión.

6.2.2.2. Regresión de las coordenadas reales de la imagen

En este apartado se procede a utilizar el conjunto de datos diseñado en el apartado anterior para

realizar el aprendizaje y el entrenamiento de un algoritmo de regresión que devuelva una predicción

de las coordenadas reales, X e Y, de la pieza.

Cabe decir que, en el conjunto de datos creado de 4 columnas, las dos primeras pertenecen a las

entradas del sistema y reciben el nombre de atributos, mientras que las otras dos pertenecen a las


55

salidas y normalmente se denominan clase o target. Dado a que estas columnas target están

compuestas por valores continuos o reales, el método utilizado para la predicción recibe el nombre de

algoritmo de regresión. Además, debido a que hay dos variables que se pretenden predecir, es

necesario realizar un doble aprendizaje, uno para cada variable, para dar una predicción a nuevos

ejemplos.

Por otra parte, es necesario destacar que la regresión de la coordenada x de la imagen dará como

resultado de su regresión un valor Y del robot, mientras que la regresión de la coordenada y de la

imagen dará como resultado de su regresión el valor X del robot. Este hecho es debido a la manera en

que están definidos los ejes de coordenadas en la base del robot y a la orientación de la cámara

respecto a ellos, siendo necesario tenerlo en cuenta para resolver correctamente los problemas de

regresión.

De esta manera, los dos problemas de regresión que se han de resolver son los siguientes:

Regresión 1: Se ha de utilizar un algoritmo que, teniendo como entrada un valor de “CentroX”,

sea capaz de obtener como salida un valor de “Y_robot”.

Regresión 2: Se ha de utilizar un algoritmo que, teniendo como entrada un valor de “CentroY”,

sea capaz de obtener como salida un valor de “X_robot”.

Fig. 6.12. Problemas de regresión de coordenadas X e Y.

A continuación, se procede a cargar el conjunto de datos en Spyder y a realizar el preprocesamiento

necesario para la posterior aplicación de algoritmos de regresión.

El primer paso a realizar es una mezcla aleatoria de los datos de coordenadas introducidos, esto se

realiza gracias al módulo “shuffle” de la librería “Sklearn” de Python. Seguidamente, se divide el

conjunto de datos en dos subconjuntos, uno destinado al entrenamiento del algoritmo de regresión y

Memoria

56

el otro destinado a la validación o test de dicho algoritmo. En este caso, el conjunto de entrenamiento

está formado por un 67% de los datos de coordenadas y el 33% restante pertenece al conjunto de test.

El siguiente paso de preprocesamiento es la normalización de los datos, de manera que, siguiendo la

fórmula de la estandarización, donde µ es la mediana y Ბ la desviación estándar, se procede a aplicarla

en cada uno de los datos de entrada, permitiendo obtener unos mejores resultados.

X′ = X−μ

τ (Ec. 10)

Una vez realizado todo el preprocesamiento, los dos conjuntos que se obtienen al realizar la mezcla, la

separación y la normalización, las 10 primeras filas de cada uno son las siguientes:

Tabla 6.2. Conjunto de datos mezclado, separado y normalizado.

A continuación, se procede a realizar una regresión para la coordenada X y otra para la coordenada Y,

experimentando con varios algoritmos para observar aquellos que aportan mejores resultados. Para

realizar la valoración de los resultados, se procede a utilizar el error R2, el cual tiene un valor

comprendido entre 0 y 1, siendo los mejores resultados aquellos que tengan un valor más cercano a 1.

En la Figura 6.13. se recogen los resultados obtenidos con los distintos algoritmos de regresión

empleados.


57

Fig. 6.13. Resultados obtenidos de error R2 para las coordenadas X e Y del robot.

Observando los resultados obtenidos con los distintos algoritmos de regresión utilizados, se puede

concluir que, excepto con los algoritmos SVM y MLP, se obtienen unos valores de error R2 muy

cercanos a 1, lo que significa que los algoritmos son capaces de dar buenas predicciones de la

coordenada real del robot. Sin embargo, el algoritmo que se acerca más a 1 y tarda menos tiempo en

ejecutarse es el algoritmo de regresión lineal.

De esta manera, se procede a seleccionar este algoritmo para predecir las coordenadas X e Y reales del

robot, teniendo en cuenta a la hora de la ejecución de la aplicación los dos siguientes modelos:

Rgs_x: Tiene como entrada la coordenada “CentroY” y realiza una predicción de la coordenada

real “X”.

Rgs_y: Tiene como entrada la coordenada “CentroX” y realiza una predicción de la coordenada

real “Y”.

Con el objetivo de predecir nuevos datos de coordenadas X e Y, es necesario normalizar las

coordenadas con los valores de mediana y desviación estándar del conjunto de datos y, seguidamente,

proceder a realizar la predicción mediante la función “. predict” de la librería Scikit-Learn. El código a

utilizar para realizar la regresión de nuevos datos de coordenadas es el siguiente, donde centroX y

centroY son las coordenadas de los centroides de los contornos obtenidos en el apartado 6.2.1.

Memoria

58

El siguiente paso es la comprobación del correcto funcionamiento de los modelos de regresión,

introduciendo datos de coordenadas de la imagen para realizar la transformación a coordenadas del

robot. Para ello, se procede a utilizar el subconjunto de test para realizar una comparación entre las

predicciones que aportan los modelos de regresión a los datos de centroides de la imagen y las

coordenadas reales del robot de estas coordenadas de imagen. De esta manera, en la Tabla 6.3. se

muestran los resultados obtenidos para 10 datos del subconjunto de test.

Tabla 6.3. Resultados obtenidos en la regresión de coordenadas X e Y.

A partir de la comparación entre las coordenadas reales del robot y las coordenadas obtenidas

mediante la predicción de los dos algoritmos de regresión, se puede observar una ligera diferencia

entre ellos. Dado que las coordenadas reales están expresadas en mm respecto la base del robot, la

diferencia en la mayoría de casos es de entre 1 y 3 mm, resultados considerados como muy

satisfactorios.

Por otra parte, existen casos en que la diferencia es mayor, como es el caso del índice 24 que se aprecia

en la Tabla 6.3., donde la coordenada real X del robot es de 209.27 y la predicción del modelo es de

221.89, mientras que la coordenada real Y del robot es de – 92.2 mm y la predicción del modelo es de

-105.96 mm. Sin embargo, estas diferencias no comprometen demasiado el funcionamiento de la

aplicación, debido a que ha sido comprobado que la pinza del brazo robótico es capaz de recoger los

distintos cubos a pesar de estas pequeñas diferencias extremas de poco más de 1 cm.


59

Finalmente, se procede a realizar la transformación de las coordenadas de imagen obtenidas en el

apartado 6.2.1. a coordenadas interpretables por el robot mediante los algoritmos de regresión

implementados, redondeando el resultado a 3 decimales mediante la función round () de Python. Las

coordenadas obtenidas como resultado se muestran en la Figura 6.14.

Fig. 6.14. Transformación de coordenadas de imagen a coordenadas del robot.

De esta manera, se consideran correctos los modelos creados para la regresión de coordenadas,

logrando solucionar el problema de localización de los cubos situados sobre el tablero. El código Python

utilizado para la carga del conjunto de datos de coordenadas, su respectivo procesamiento y la

creación y entrenamiento de los modelos de regresión de coordenadas X e Y se puede encontrar en el

Anexo A1.

Memoria

60

7. Reconocimiento de letras y orientación

El siguiente problema a resolver para el funcionamiento de la aplicación es el reconocimiento de las

letras que contienen las distintas ROIs de la imagen capturada, además de también sus orientaciones

para que el robot sea capaz de recogerlas adecuadamente.

A continuación, se procede a explicar los distintos experimentos realizados para establecer el método

más adecuado para realizar el correcto reconocimiento de las letras y sus respectivas orientaciones.

7.1. Experimento 1: CNN reconocimiento de letras

En este primer experimento, se pretende desarrollar una red neuronal convolucional (CNN) que sea

capaz de llevar a cabo el reconocimiento de las letras, con la limitación de que estas no pueden estar

rotadas ni inclinadas.

Fig. 7.1. Experimento 1: CNN reconocimiento de letras.

Los pasos a seguir para realizar este reconocimiento de las letras son los siguientes:

Selección del conjunto de datos de entrenamiento.

Definición de la arquitectura de la red neuronal.

Entrenamiento de la red.

Obtención de resultados

7.1.1. Selección del conjunto de datos de entrenamiento

Un sistema de clasificación basado en Deep Learning, concretamente en redes neuronales como es en

este caso, requiere de un conjunto de datos lo suficientemente amplio y simbólico para realizar un

correcto entrenamiento y, así, obtener unos resultados óptimos en el problema de clasificación.


61

Con el objetivo de entrenar la red neuronal que se va a proceder a diseñar para resolver la clasificación

y el reconocimiento de las letras, ha sido escogido el conjunto de datos Chars74k [21]. Este dataset fue

creado por T. de Campos y M. Varma en Microsoft Research India y cuenta con un total aproximado

de 74.000 imágenes de números (0-9) y letras (a-z, A-Z) en formato PNG que se clasifican en tres

colecciones:

7705 caracteres extraídos de escenas cotidianas.

3410 caracteres manuscritos utilizando una Tablet.

62992 caracteres generados por ordenador.

Concretamente, la última colección, llamada EnglishFnt.tgz, consta de imágenes binarizadas de

tamaño 100x100 píxeles, de caracteres generados por ordenador con 4 estilos distintos,

combinaciones de normal, negrita y cursiva.

Por lo tanto, esta colección se adapta completamente al problema propuesto y permite a la red

neuronal CNN reconocer patrones en las distintas letras del abecedario. Dado que es esta colección la

seleccionada como conjunto de datos de entrenamiento, en la Figura 7.2. se muestra una imagen para

poder observar el aspecto que tiene.

Fig. 7.2. Muestras de letras A de la colección EnglishFnt del dataset Chars74k.

Aun así, existen imágenes de letras que no son aptas para la clasificación de las letras utilizadas en la

aplicación, siendo necesaria la eliminación de caracteres en minúscula o con tipografías extrañas como

los que se pueden observar en la Figura 7.3.

Memoria

62

Fig. 7.3. Muestras de letras A no aptas para la aplicación.

Una vez eliminadas estas letras no aptas, ya se dispone del conjunto de datos preparado para llevar a

cabo el entrenamiento de la red neuronal para conseguir reconocer las letras capturadas por la cámara.

Concretamente, el número total de imágenes en el conjunto de datos resultante es de 25.073, en la

Tabla 7.1. se muestra el número de ejemplos que se tiene finalmente para cada letra.

Tabla 7.1. Número de ejemplos de cada letra utilizados en Experimento 1.

Letra Nº de ejemplos Letra Nº de ejemplos

A 972 N 968

B 955 O 988

C 976 P 968

D 952 Q 956

E 965 R 980

F 976 S 976

G 939 T 952

H 988 U 926

I 952 V 964

J 952 W 960

K 972 X 984

L 976 Y 944


63

M 964 Z 968

7.1.2. Definición de la arquitectura de la red CNN

La definición de la arquitectura de la red CNN utilizada para la clasificación de las letras está basada en

la red convolucional LeNet-5 propuesta por Yann Lecun para el reconocimiento de dígitos [23],

adaptando sus distintos parámetros al problema de este proyecto.

Las imágenes del conjunto de entrenamiento seleccionado son de tamaño 100x100 píxeles, sin

embargo, se ha decidido modificar su tamaño a 32x32 debido a que esto provoca una reducción de la

complejidad de la red y de su tiempo de entrenamiento, sin comprometer demasiado la calidad de la

imagen para su correcto reconocimiento. De esta manera, la entrada de la red recibe un total de 1.024

neuronas (32x32).

Cabe decir que la arquitectura original de la red LeNet-5 consiste en dos grupos de capas

convolucionales y de reducción, seguidas de dos capas totalmente conectadas. Aun así, se ha

experimentado con el número de capas convolucionales y se ha podido observar una mejor precisión

añadiendo un tercer grupo de capa convolucional y de reducción. Además, se ha optado por un

tamaño de Kernel de 5x5 con 64 filtros para las dos primeras capas convolucionales y un Kernel de 3x3

para la última, todas ellas con función de activación Relu y seguidas por su capa de reducción 2x2 para

reducir sus respectivos tamaños a la mitad.

Por otra parte, se ha decidido mantener el número de capas totalmente conectadas (FC) a dos, debido

a que una disminución de estas provoca un resultado peor y, al añadir otra de estas capas, la red

neuronal no es capaz de converger y obtiene resultados inválidos. En concreto, se opta por una primera

capa FC con 1024 neuronas y función de activación Relu, seguida de otra capa final FC de 26 neuronas

(igual al número total de letras de la aplicación) con función de activación Softmax, la cual es utilizada

para obtener la probabilidad de la imagen de pertenecer a cada una de las clases.

Finalmente, se ha optado por añadir una capa llamada Dropout, cuya función es básicamente

desconectar ciertas neuronas de las capas totalmente conectadas con el objetivo de reducir el

problema de overfitting.

De esta manera, la red CNN definida para conseguir el correcto reconocimiento de letras tiene la

arquitectura que se puede observar en la Figura 7.4.

Memoria

64

Fig. 7.4. Arquitectura red CNN.

7.1.3. Entrenamiento de la red

Una vez establecida la arquitectura de la red neuronal convolucional, se procede a realizar la

preparación de los datos y se experimenta con los distintos parámetros posibles para observar la

combinación que aporta mejores resultados en el entrenamiento.

Para empezar, se divide el tamaño total de imágenes de letras en los tres grupos siguientes:

Conjunto de entrenamiento: 80% total, 20.058 imágenes.

Conjunto de test: 16% total, 4.012 imágenes.

Conjunto de validación: 4% total, 1.003 imágenes.

Las imágenes de cada subconjunto son convertidas a un vector de 4 dimensiones, en el caso del

conjunto de entrenamiento, este vector es de (20058,32,32,1). Además, se convierten a tipo float32

de Python dado que esto facilita el entrenamiento de la red neuronal.

Seguidamente, se procede a aplicar una codificación “One-hot encoding” de la salida de cada una de

las imágenes, de manera que ahora las salidas ya no son un dígito entre el 0 (A) y el 25 (Z), sino que

están representadas por un vector binario, donde todo son 0s excepto un 1, situado en la posición de

la letra reconocida. De esta manera, se consigue que algoritmos como las redes neuronales obtengan

mejores resultados en problemas de clasificación.

Fig. 7.5. Codificación One-hot Encoding.


65

Con el conjunto de datos ya preparado para el entrenamiento, se procede a realizar experimentos para

realizar el ajuste de los distintos hiperparámetros de la red, es decir, el optimizador a utilizar, el tamaño

del lote y el número de épocas.

7.1.3.1. Función de pérdidas y exactitud

La función de pérdidas, o también llamada función de coste, trata de determinar el error entre el valor

estimado y el valor real, con el fin de optimizar los distintos parámetros de la red neuronal. Las

funciones de error más populares que se utilizan actualmente son RMSE, MAE, MASE, entropía cruzada

categórica y entropía cruzada binaria.

Dado que la red neuronal diseñada pretende aportar predicciones a la letra observada en las distintas

imágenes, se procede a seleccionar la función de entropía cruzada categórica (en inglés Binary Cross-

Entropy). Esto es debido a que esta función es la más utilizada como medida de precisión en problemas

de clasificación, dado que genera una probabilidad de que la imagen introducida en la red pertenezca

a cada una de las variables categóricas, en este caso, las letras del abecedario.

Por otra parte, para realizar una valoración de los resultados obtenidos, se utiliza la métrica accuracy,

también llamada en castellano exactitud o precisión. Esta métrica se define como la fracción entre el

número de predicciones correctas entre el número de predicciones totales, obteniendo un valor

comprendido entre 0 y 1.

La fórmula para medir la accuracy del modelo de clasificación de letras es la siguiente, donde el

numerador es el número de letras verdaderas o identificadas correctamente por la red (VA + VB + …+

VZ) y el denominador es la cantidad total de letras introducidas en el entrenamiento (VA + FA + … + VZ

+ FZ)

Accuracy = VA+VB+⋯+VZ

VA+FA+⋯+VZ+FZ (Ec. 11)

7.1.3.2. Selección del optimizador

El primer parámetro que se procede a ajustar para realizar el entrenamiento de la red neuronal es el

optimizador. Existen distintos optimizadores dentro de la librería Keras de Python, entre los que

destacan SGD, RMSprop y Adam.

Memoria

66

A continuación, se establece el número de épocas (epochs) a 50, el tamaño de lote (batch_size) a 100

y se realiza el entrenamiento de la red con cada uno de los optimizadores mencionados.

Los resultados obtenidos son mejores a medida que el valor de accuracy es más cercano a 1 y el valor

de loss es más cercano a 0.

En la Tabla 7.2. se pueden observar los valores obtenidos de accuracy y loss para los conjuntos de

entrenamiento, test y validación utilizando los distintos optimizadores.

Tabla 7.2. Resultados obtenidos con optimizadores SGD, Adam y RMSprop.

Entrenamiento Validación Test

Optimizador Acc Loss Acc Loss Acc Loss

SGD 0,9847 0,0599 0,9797 0,0807 0,9773 0,1046

Adam 0,9973 0,0088 0,9831 0,1792 0,9885 0,0961

RMSprop 0,9988 0,0057 0,9870 0,1971 0,9890 0,2026

Como se puede observar, los resultados obtenidos con los tres optimizadores utilizados son bastante

similares y pueden ser considerados como excelentes debido a que los valores de accuracy son muy

cercanos a 1, lo que significa que la red ha realizado predicciones correctas en el 99% de las imágenes.

Aunque con los tres se obtienen buenos resultados, se decide utilizar el algoritmo RMSprop para

realizar el entrenamiento de la red CNN.

7.1.3.3. Selección del tamaño de lote (batch_size)

El siguiente hiperparámetro a ajustar en el entrenamiento de la red neuronal es el tamaño de lote (en

inglés batch size). Este tamaño es el número de datos que tiene cada iteración de un ciclo, es decir, es

un número de datos más pequeño que el total y se ajusta para hacer que la red neuronal sea entrenada

más rápidamente.

A continuación, se establece el número de épocas a 50, el optimizador seleccionado es RMSprop y se

experimenta con tamaños de lote de 50, 100 y 200. En este caso la función de loss también es


67

“categorical_crossentropy. En la Tabla 7.3. se encuentran los resultados obtenidos para cada uno de

los tamaños.

Tabla 7.3. Resultados obtenidos con batch_size 50, 100 y 200.


Batch_size Acc Loss Acc Loss Acc Loss

50 0.9983 0.0170 0.9900 0.0778 0.9858 0.2832

100 0.9988 0.0057 0.9870 0.1971 0.9890 0.2026

200 0.9988 0.0045 0.9900 0.0365 0.9870 0.1034

Observando los resultados obtenidos con los distintos valores de batch_size, se puede comprobar que

se obtienen valores muy similares de accuracy en los distintos tamaños de lote, sin embargo, se puede

apreciar un valor de loss más cercano a 0 para un tamaño de lote de 200. Por eso mismo, se selecciona

batch_size = 200 para realizar el entrenamiento de la red neuronal.

7.1.3.4. Selección del número de épocas (epochs)

El último hiperparámetro de la red que se procede a ajustar es el número de épocas (epochs) de

entrenamiento, lo que es básicamente el número de veces que los datos de entrenamiento son

insertados en la red con el fin de que esta aprenda sobre ellos.

En este caso, el optimizador utilizado sigue siendo RMSprop, se establece un tamaño de lote de 200 y

se experimenta con un número de épocas de entrenamiento de 25, 50 y 100. En la Tabla 7.4. se

muestran los resultados obtenidos al realizar el entrenamiento con los distintos números de épocas.

Memoria

68

Tabla 7.4. Resultados obtenidos con 25, 50 y 100 épocas.


Épocas Acc Loss Acc Loss Acc Loss

25 0,9971 0,0093 0,9940 0,0354 0,9897 0,0427

50 0,9984 0,0055 0,9870 0,0842 0,9873 0,0949

100 0,9994 0,0025 0,9870 0,0867 0,9895 0,1472

Además, en la Figura 7.6. se muestran las gráficas obtenidas de los valores de accuracy y de loss a lo

largo de las 100 épocas para los conjuntos de entrenamiento y de validación.

Fig. 7.6. Gráficas de accuracy y loss con 100 épocas.

Observando las gráficas de accuracy y loss en función de las épocas de entrenamiento y los resultados

obtenidos en la Tabla 7.4., se puede comprobar que la accuracy se mantiene constante a partir de la

época 25 aproximadamente, por lo que a partir de estas épocas la red ya es capaz de reconocer

correctamente un 99% de las letras, sin variar demasiado este resultado en las siguientes épocas y

coincidiendo aproximadamente el valor obtenido del conjunto de entrenamiento con el de validación.

Por lo que respecta al valor de las pérdidas (loss) del modelo, se puede comprobar que a partir de la

época 25 se mantiene constante con un valor aproximadamente nulo para el conjunto de

entrenamiento y de aproximadamente 0,1 para el conjunto de validación. Sin embargo, a partir de la


69

época 60 se puede notar un ligero aumento de las pérdidas del conjunto de validación, significando

esto que se puede estar ocasionando el problema de overfitting en el entrenamiento.

Por estos motivos, se decide realizar el entrenamiento de la red CNN para el reconocimiento de letras

con 50 épocas, valor apto para no incurrir en overfitting y dejando que la red sea capaz de entrenar

más que con solo 25 épocas.

Una vez realizados los distintos experimentos para diferentes valores de los hiperparámetros de la red

neuronal, los hiperparámetros fijados para el entrenamiento son los siguientes:

Optimizador: RMSprop

Tamaño de lote: 200

Número de épocas: 50

Los resultados obtenidos finalmente de accuracy y loss de los conjuntos de entrenamiento, validación

y test en la red neuronal diseñada son los que se muestran en la Tabla 7.5.

Tabla 7.5. Resultados obtenidos de accuracy y loss en el Experimento 1.


Acc Loss Acc Loss Acc Loss

0,9984 0,0055 0,9870 0,0842 0,9873 0,0949

Para estos hiperparámetros, la red CNN entrenada posee un total de 234.266 parámetros, quedando

definido su respectivo modelo en la Figura 7.7.

Memoria

70

Fig. 7.7. Modelo red CNN reconocimiento de letras.

7.1.4. Obtención de resultados

Realizando el entrenamiento de la red CNN, se obtienen las siguientes gráficas de valores de accuracy

y de loss a lo largo de las 50 épocas de entrenamiento, pudiendo observarse que no se llega a producir

overfitting y se alcanza una accuracy muy cercana a 1.



71

A continuación, se muestra en la Tabla 7.6. la matriz de confusión de la red neuronal entrenada. En esta matriz se puede observar el número de imágenes de cada letra que la red ha acertado y también las letras con las que se ha confundido. Las filas de la matriz son las letras reales del conjunto de test y las columnas corresponden a las predicciones de cada letra aportadas por la red. Se puede comprobar también que la red entrenada ha sido capaz de reconocer correctamente la mayoría de las letras, entre ellas el total de las imágenes de letras J (139), P (132), T (163), U (161), V (151) y W (150). Sin embargo, del total de 153 imágenes de la letra M, la red ha confundido 5 por letra N y 1 por la letra P.

Memoria

72

Tabla 7.6. Matriz de confusión del conjunto de test Experimento 1.


73

Finalmente, se procede a comprobar que la red entrenada es capaz de reconocer, además de las

imágenes del conjunto de datos EnglishFnt, imágenes de letras reales de la aplicación. En la Tabla 7.7.

se muestran las predicciones obtenidas al introducir las distintas ROIs detectadas en las imágenes en

la red CNN entrenada.

Tabla 7.7. Resultados CNN reconocimiento de letras.

Imágenes de prueba ROIs Reconocimiento de letras

[‘A’, ‘N’, ‘G’, ‘E’, ‘L’ ]

[‘S’, ‘E’, ‘B’, ‘A’, ‘S’, ‘T’, ‘I’, ‘A’, ‘N’ ]

[‘G’, ‘E’, ‘R’, ‘A’, ‘R’, ‘D’ ]

[ ‘M’, ‘A’, ‘R’, ‘I’, ‘O’ ]

[‘I’, ‘R’, ‘E’,’N’, ‘E’ ]

Memoria

74

[‘M’, ‘A’, ‘R’, ‘T’, ‘I’, ‘N’, ‘A’ ]

[‘N’,’U’, ‘R’, ‘I’, ‘A’ ]

[‘C’, ‘A’, ‘R’, ‘L’, ‘O’, ‘S’ ]

[‘F’, ‘R’, ‘A’, ‘N’, ‘C’, ‘I’, ‘S’, ‘C’, ‘O’ ]

[‘C’, ‘H’, ‘R’, ‘I’, ‘S’, ‘T’, ‘I’, ‘A’, ‘N’ ]

Observando los resultados, se puede comprobar el correcto funcionamiento del modelo de red CNN

entrenado para el reconocimiento de letras, dado que es capaz de reconocer correctamente todas las

ROIs de las distintas imágenes de prueba.

El código Python utilizado para la carga del conjunto de imágenes de entrenamiento, su respectivo

procesamiento y la creación y entrenamiento del modelo de red neuronal CNN para el reconocimiento

de letras se puede encontrar en el Anexo A2.


75

7.2. Experimento 2: Detección del ángulo de inclinación de las ROIs

En este segundo experimento, se procede a llevar a cabo la detección del ángulo de inclinación de cada

región de interés (ROI) identificada en la imagen capturada por la cámara. En este caso, no se tiene en

cuenta ni la letra contenida ni su respectiva orientación, solamente se desea tener la ROI alineada con

los ejes de la imagen capturada.

Este ángulo (llamado α) es necesario conocerlo para poder posicionar el extremo del robot

adecuadamente para recoger la letra deseada ya que, un mal posicionamiento, podría ocasionar que

el extremo impacte con la pieza o bien, que no la recoja adecuadamente. Además, el ángulo también

es necesario para reorientar las ROIs antes de introducirlas a la red de reconocimiento de letras

entrenada en el siguiente apartado.

La detección de este ángulo se realiza mediante la función utilizada en el apartado 6.1.4. para la

detección de los contornos de las ROIs de la imagen. Concretamente, el código utilizado para este

experimento es una ampliación de ese mismo apartado, sin embargo, ahora es la variable “rect” la que

interesa. Esta variable es la que forma el contorno de cada ROI de la imagen y contiene tres datos sobre

ellos, el tercero de los cuales corresponde al ángulo de inclinación de cada contorno respecto los ejes

de la imagen.

Es necesario tener en cuenta que el ángulo se calcula respecto el extremo inferior de la región, como

se puede observar en Figura 7.10, que muestra el funcionamiento de este Experimento 2.

Fig. 7.9. Ángulo de inclinación calculado.

En el código utilizado se crea una lista llamada “ángulos” la cual se encarga de guardar el ángulo

detectado para cada una de las regiones. Además, cada ROI es rotada para quedar girada solamente

en los ángulos de 0, 90, 180 o 270, ángulos aptos para el reconocimiento de letras implementado en

el Experimento 2.

Memoria

76

Con el objetivo de comprobar el funcionamiento de este segundo experimento, se procede a capturar

distintas imágenes con diferentes ángulos de inclinación en los cubos presentes. En la Tabla 7.8. se

muestran las imágenes utilizadas, los ángulos de inclinación de los distintos contornos obtenidos y las

ROIs de la imagen reorientadas. Cabe destacar que todos estos ángulos son negativos y tienen un valor

entre 0 y -90 grados.

Tabla 7.8. Resultados detección del ángulo de inclinación.

Imágenes de prueba Ángulos de inclinación ROIs reorientadas

[-80, -63, -73, -35, 0 ]

[-45, -26, -72, -53, -88, -73, -74,

-69, -30 ]

[-8, -0, -87, -70, -67 ]

[-7, 0, -30, -45, -71, -30, 0 ]

[-35, -65, -37, -45, -85, -22, -66,

-55, -39 ]


77

[-58, -85, -33, -45, -5, -32 ]

[-7, -83, -25, -27, -39 ]

[-76, -53, -40, -10, -54 ]

[-27, -38, -21, -26, -2, -27 ]

[-72, -41, -59, -72, -53, -49, -45,

-37, -23 ]

De esta manera, se puede observar que todas las ROIs detectadas quedan reorientadas

aproximadamente unos ángulos de 0, 90, 180 o 270 grados, aptas para ser reconocidas por la red CNN

entrenada en el siguiente experimento.

El código Python utilizado para la detección y extracción de ROIs consiste en una adaptación del código

utilizado en el capítulo 6, obteniendo como resultado en este caso una lista con los ángulos de

inclinación y las imágenes rotadas 0, 90, 180 o 270 grados, además de los centroides ya encontrados

en dicho capítulo. Este código se puede observar en el Anexo A3.

Memoria

78

7.3. Experimento 3: CNN reconocimiento de letras rotadas

En este tercer experimento, se pretende comprobar el correcto funcionamiento de la red neuronal

CNN diseñada en el Experimento 1 para llevar a cabo el mismo reconocimiento de letras, pero ahora

siendo posible que estas puedan estar rotadas unos ángulos de 0,90, 180 y 270 grados.

Fig. 7.10. CNN reconocimiento de letras rotadas.

El conjunto de datos utilizado para la realización del nuevo entrenamiento de la red CNN de este

experimento consiste en una ampliación del conjunto de datos utilizado en el Experimento 1.

Concretamente, se han realizado rotaciones de cada una de las imágenes del conjunto unos ángulos

de 0, 90, 180 y 270 con el fin de entrenar la red diseñada para que sea capaz de reconocer las distintas

letras del abecedario, aunque estén rotadas estos ángulos.

Cabe destacar que, en este nuevo conjunto de imágenes ya no hay letras no aptas para la clasificación,

debido a que se han realizado las cuatro rotaciones sobre cada una de las imágenes del conjunto de

datos final del Experimento 1.

En la Figura 7.11. se muestra unas imágenes de la letra A para observar el aspecto del nuevo conjunto

de imágenes.


79

Fig. 7.11. Muestras de letras A del conjunto de datos rotado.

De esta manera, el número total de imágenes en este nuevo conjunto de datos es de 100.292 y, como

se puede comprobar en la Tabla 7.9, el número de ejemplos para cada letra ha sido multiplicado por

cuatro, ya que cada imagen ha sido rotada 4 veces (0, 90, 180 y 270).

Tabla 7.9. Número de ejemplos de cada letra utilizado en el conjunto rotado.

Letra Nº de ejemplos Letra Nº de ejemplos

A 3888 N 3872

B 3820 O 3952

C 3904 P 3872

D 3808 Q 3824

E 3860 R 3920

F 3904 S 3904

G 3756 T 3808

H 3952 U 3704

I 3808 V 3856

Memoria

80

J 3808 W 3840

K 3888 X 3936

L 3904 Y 3776

M 3856 Z 3872

Para el entrenamiento de la red, se procede a seleccionar el mismo optimizador (RMSprop) y el mismo

número de épocas (50) que los de la red utilizada en el experimento anterior. Sin embargo, se opta por

cambiar el tamaño de lote a 300 debido a que el tamaño de imágenes es mucho mayor que en el

Experimento 1 y así se consigue evitar el problema de overfitting.

En este caso, se divide el tamaño total de imágenes de letras en los tres grupos siguientes:

Conjunto de entrenamiento: 80% total, 79.947 imágenes.

Conjunto de test: 16% total, 15.989 imágenes.

Conjunto de validación: 4% total, 3.998 imágenes.

Realizando el nuevo entrenamiento de la red CNN, se obtienen las gráficas de la Figura 7.12. de valores

de accuracy y de loss a lo largo de las 50 épocas de entrenamiento.



81

Se puede observar que la accuracy obtenida es muy correcta y se mantiene casi constante a partir de

la época 20 con un valor de 0,9967 para el conjunto de entrenamiento y de 0,95 para el conjunto de

validación.

Con lo que respecta al valor de las pérdidas, se comprueba que para el conjunto de entrenamiento

tiene un valor de aproximadamente 0 a partir de la época 20 y queda estabilizado, mientras que en el

conjunto de validación se puede apreciar un poco de overfitting, aunque se obtiene un valor de 0,15

en la época 50, valor considerado aceptable.

Los resultados obtenidos de accuracy y de loss para los conjuntos de entrenamiento, validación y test

en el entrenamiento de la red se pueden observar en la Tabla 7.10.

Tabla 7.10. Resultados obtenidos de accuracy y loss en el Experimento 3.


Acc Loss Acc Loss Acc Loss

0,9967 0,0144 0,9800 0,1506 0,9763 0,2240

Por otra parte, en la Tabla 7.11. se muestra la matriz de confusión obtenida al realizar predicciones del

conjunto de test con la red CNN entrenada para el reconocimiento de letras rotadas. En este

entrenamiento, la nueva red CNN de este experimento es capaz de reconocer también la mayoría de

las letras insertadas, sin embargo, se puede apreciar una confusión entre dos letras que cabe destacar.

Este es el caso de las letras M y W, dado que en esta red ahora se han introducido las letras giradas 0,

90, 180 y 270 grados, se produce el hecho de que las letras M giradas 0 y 90 grados corresponden de

manera similar a aquellas letras W giradas 180 y 270 grados, mientras que las letras M rotadas 180 y

270 grados son muy similares a las letras W rotadas 0 y 90 grados. Este hecho provoca un número

superior de confusiones ya que, del total de 600 imágenes de letras W introducidas en el

entrenamiento de la red, 52 de ellas son confundidas por la letra M. Respecto al reconocimiento de las

letras M reales, la red solamente identifica 5 de ellas con la letra W, confundiendo también 2 de ellas

por la letra H, letra que también puede generar problemas en el reconocimiento.

Memoria

82

Otras letras que pueden causar confusión en la red neuronal son la N y la Z, dado que las orientaciones

de 90 y 270 grados de la letra N son muy similares a las orientaciones de 0 y 180 grados de la letra Z y

viceversa.

Sin embargo, a pesar de estos pequeños errores, se considera que la red funciona correctamente dado

que la suma de los términos de la diagonal de la matriz de confusión es mucho más elevada que el

número de fallos, correspondiendo a un accuracy del 0,9763 como se observa en la anterior tabla.


83

Tabla 7.11. Matriz de confusión del conjunto de test Experimento 3.

Memoria

84

Para finalizar el Experimento 3, se procede a comprobar que la red entrenada es capaz de reconocer,

además de las imágenes del conjunto de datos, imágenes de letras reales de la aplicación. Con este

objetivo, se utilizan las ROIs extraídas y rotadas sus respectivos ángulos de inclinación de las distintas

imágenes empleadas en el Experimento 2 para encontrar una predicción mediante la red CNN

entrenada a la letra que contienen.

En la Tabla 7.12. se muestran los resultados obtenidos al introducir las distintas ROIs en la red CNN

entrenada en este experimento.

Tabla 7.12. Resultados CNN reconocimiento letras rotadas.

Imágenes de prueba ROIs Reconocimiento de letras

[‘G’, ‘A,’ ‘E’, ‘N’, ‘L’]

[‘I’, ‘N’, ‘A’, ‘T’, ‘A’, ‘E’, ‘B’, ‘S’, ‘S’ ]

[‘E’, ‘E’, ‘R’, ‘M’, ‘I’ ]

[‘N’, ‘T’, ‘A’, ‘I’, ‘R’, ‘A’, ‘M’ ]


85

[‘I’, ‘A’, ‘C’, ‘S’, ‘H’, ‘R’, ‘N’, ‘T’, ‘I’ ]

[‘D’, ‘R’, ‘E’, ‘A’, ‘R’, ‘G’ ]

[‘O’, ‘I’, ‘R’, ‘M’, ‘A’ ]

[‘N’, ‘U’, ‘I’, ‘A’, ‘R’ ]

[‘S’, ‘R’, ‘C’, ‘A’, ‘L’, ‘O’ ]

[‘O’,’S’, ‘A’, ‘R’, ‘N’, ‘I’, ‘F’, ‘C’, ‘C’ ]

Se puede observar que la red neuronal es capaz de reconocer correctamente la mayoría de las letras

introducidas, excepto en la tercera imagen que confunde la letra N por la letra M. Por lo tanto, se

considera solucionado el problema de reconocimiento de letras necesario para llevar a cabo la

aplicación demostrativa.

Memoria

86

El código Python utilizado para la carga del conjunto de imágenes de entrenamiento, su respectivo

procesamiento y la creación y entrenamiento del modelo de red neuronal CNN se puede encontrar en

el Anexo A4. Además, se incluye al principio de este Anexo el código correspondiente a la rotación

mediante Python de las imágenes contenidas en un mismo directorio del ordenador, utilizado para

generar las nuevas imágenes de este experimento.

7.4. Experimento 4: Detección orientación 0-90-180-270

Una vez que se han reconocido las distintas ROIs de la imagen capturada mediante la red neuronal

CNN entrenada en el Experimento 3, es necesario conocer el ángulo de rotación (llamado β) de la letra

contenida en la región para poder colocarla adecuadamente para formar el nombre. Los ángulos de

rotación posibles son 0, 90, 180 y 270 grados, debido a que en el anterior experimento ya se han rotado

las imágenes para que solamente sea posible que estén giradas esos ángulos.

Con este objetivo, en este último experimento se procede implementar una red para cada una de las

letras posibles en la aplicación (en total 26) con el objetivo de realizar una clasificación de los 4 ángulos

de orientación posibles.

Fig. 7.13. Experimento 4: Detección orientación 0-90-180-270.

De esta manera, una vez reconocida la letra mediante el modelo definido en el Experimento 3, se

procede a utilizar su respectivo modelo para obtener el reconocimiento de su orientación, siguiendo

el procedimiento de la Figura 7.14. con el caso de la letra A. Con la adición de este experimento al

Experimento 3, se consigue resolver tanto el problema de reconocimiento de letras como el de su

rotación.


87

Fig. 7.14. Funcionamiento Experimento 3 + Experimento 4.

El conjunto de imágenes utilizado en este experimento es el mismo que en el experimento anterior,

con la diferencia de que ahora las salidas a reconocer no son las letras, sino su respectiva rotación. Por

este motivo, se ha dividido el conjunto de imágenes en función de las letras y, además, se ha dividido

cada letra en función del ángulo de orientación.

A continuación, se implementa la misma arquitectura de red CNN que en el Experimento 3, con la

diferencia de que en la última capa densamente conectada con función Softmax, el número de

neuronas en este experimento es 4, correspondiente a la clasificación de los cuatro ángulos (0, 90, 180

y 270). Esta nueva red se implementa para el reconocimiento de las orientaciones de cada letra,

creando un modelo para cada una de ellas.

Fig. 7.15. Arquitectura red CNN reconocimiento orientación.

Memoria

88

Se selecciona el mismo optimizador RMSprop, el tamaño de lote igual a 200 y el número de épocas de

entrenamiento a 20, de manera que se muestran en la Tabla 7.13. los resultados obtenidos en el

entrenamiento de los modelos de cada una de las letras.

Tabla 7.13. Resultados obtenidos en los entrenamientos en el Experimento 4.

Acc_Train Acc_Val Acc_Test Loss_Train Loss_Val Loss_Test

A 1 1 1 0 0 0

B 1 1 0,9984 0 0 0,0372

C 1 0,9936 0,9968 0 0,2071 0,0140

D 0,9997 0,9935 1 0,0006 0,0138 0,0011

E 1 1 1 0 0,0054 0,0001

F 0,9987 0,9936 0,9856 0,0019 0,0139 0,0581

G 0,9970 1 0,9967 0,0122 0,0008 0,0160

H 0,9288 0,8176 0,8592 0,1430 0,3741 0,3709

I 0,9183 0,8170 0,8243 0,1582 0,4177 0,4008

J 0,9974 1 1 0,0121 0,0070 0,0010

K 1 1 1 0 0 0,0002

L 0,9981 0,9873 0,9936 0,0049 0,0242 0,0462

M 1 0,9872 0,9951 0 0,5524 0,0824

N 0,9813 0,8774 0,8935 0,0525 0,4253 0,4487

O 0,9595 0,7170 0,7500 0,0990 0,9493 0,8513

P 1 1 1 0 0 0,0002

Q 0,9977 0,9804 0,9902 0,0100 0,1579 0,0317


89

R 0,9965 0,9809 0,9936 0,0213 0,1191 0,0653

S 0,9872 0,9490 0,9519 0,0374 0,1084 0,1654

T 0,9970 0,9935 0,9951 0,0101 0,0666 0,0304

U 0,9980 0,9799 0,9966 0,0111 0,1224 0,0129

V 1 1 0,9968 0 0 0,0972

W 0,9997 1 0,9967 0,0011 0,0012 0,0464

X 0,9755 0,9177 0,9254 0,0579 0,2790 0,2622

Y 0,9997 1 1 0,0007 0 0

Z 0,9470 0,9032 0,9161 0,1412 0,2742 0,1952

En los resultados de la tabla anterior se puede comprobar que, en general, se obtienen unos valores

de accuracy y loss que se pueden considerar aptos para la clasificación de las orientaciones.

Por otra parte, se puede observar que las letras que son simétricas (H, I, O, S, X y Z) obtienen una

accuracy inferior que otras letras. Este hecho es debido a que la red se confunde con sus orientaciones

dado que en estas letras las orientaciones 0 y 180 coinciden y las orientaciones 90 y 270 también son

iguales. Sin embargo, este problema no afecta al correcto funcionamiento de la aplicación

demostrativa, dado que la red solamente ha de reconocer si estas letras se encuentran en la posición

vertical u horizontal para que el robot la coloque adecuadamente.

Finalmente, se comprueba también que este Experimento 4 realice predicciones de rotación correctas

sobre ROIs reales de la aplicación. De esta manera, se utilizan las mismas ROIs empleadas en el anterior

experimento para dar una predicción de la rotación de las letras contenidas en ellas. Los resultados

obtenidos se muestran en la Tabla 7.14.

Memoria

90

Tabla 7.14. Resultados CNN reconocimiento orientación.

Imágenes de prueba ROIs Reconocimiento de rotaciones

[‘0’, ’90’, ‘180’, ‘90’, ‘0’ ]

[’90’, ‘180’, ‘180’, ‘270’, ‘270’, ‘90’,

‘270’, ‘270’, ‘0’ ]

[‘90’, ‘180’, ‘270’, ‘90’, ‘90’ ]

[‘180’, ‘180’, ‘180’, ‘90’, ‘180’, ‘0’,

‘180’ ]

[‘90’, ‘270’, ‘0’, ‘270’, ‘270’, ‘180’, ‘0’,

‘180’]

[‘270’, ‘270’, ‘180’, ‘270’, ‘180’, ‘0’ ]


91

[‘0’, ‘90’ ‘0’, ‘0’, ‘270’ ]

[‘180’, ‘90’, ‘180’, ‘0’, ‘180’ ]

[‘0’, ‘0’, ‘270’, ‘0’, ‘0’, ‘0’ ]

[‘0’, ‘270’, ‘270’, ‘0’, ‘180’, ‘180’,

‘270’, ‘180’, ‘0’ ]

Observando los resultados obtenidos en el reconocimiento de las rotaciones, se puede comprobar que

los distintos modelos de red CNN definidos para cada una de las letras del abecedario aportan unas

predicciones correctas de rotación en la mayoría de los casos, excepto la letra E de la primera imagen,

la letra A de la segunda y la letra N de la cuarta.

De esta manera, se da por solucionado también el problema de reconocimiento de las orientaciones

de las letras contenidas en las ROIs de la imagen, finalizando así el Capítulo 7 de este documento.

Memoria

92

8. Implementación de la aplicación

En este capítulo se procede a explicar la implementación de la aplicación demostrativa, incluyendo el

desarrollo de la interfaz gráfica de usuario (GUI) diseñada para que el usuario introduzca su nombre

por teclado. Por otra parte, se explica también la programación del robot realizada para que recoja y

coloque las letras en el orden correcto para la formación del nombre del usuario.

8.1. Interfaz Gráfica de Usuario (GUI) y comunicación RS-232

En los capítulos 6 y 7 de este documento se explican los distintos procedimientos llevados a cabo con

el objetivo de hacer funcionar correctamente la aplicación demostrativa. De esta manera, para la

imagen capturada, se consigue extraer las distintas regiones de interés correctamente, ajustar sus

tamaños a 32x32 y binarizarlas.

Además, se obtienen 5 listas como salida de la imagen capturada:

Letras reconocidas en las ROIs.

Inclinación de las ROIs.

Rotación de las letras reconocidas.

Coordenada X real de las letras.

Coordenada Y real de las letras.

En la Figura 8.1. se muestran los resultados obtenidos como conclusión de estos capítulos para una

imagen capturada por la cámara.

Fig. 8.1. Resultados finales capítulos 6 y 7.


93

Sin embargo, para que la aplicación sea accesible es necesario el diseño de una interfaz gráfica de

usuario (GUI) que desenvuelva los resultados obtenidos en los anteriores capítulos y que, además, sea

utilizable fácilmente por el usuario y se comunique por puerto serie con el robot.

Para llevar a cabo la programación de la GUI, se procede a utilizar la librería de Python Tkinter, la cual

dispone de distintos elementos para lograr el correcto funcionamiento de la GUI de la aplicación.

Básicamente, la tarea de la GUI es permitir al usuario introducir su nombre por teclado y, mediante los

modelos de reconocimiento y regresión creados en los capítulos 6 y 7, envíe por puerto serie los datos

necesarios para que el robot sea capaz de formar el nombre con los distintos cubos ubicados sobre el

tablero.

Fig. 8.2. Partes de la aplicación demostrativa.

8.1.1. Diseño de la GUI

Concretamente, la GUI diseñada tiene un tamaño de 1300 x 650 y consta de una caja de texto,

establecida mediante el elemento “Entry” de Tkinter, donde se permite al usuario ingresar cualquier

texto de una línea, en este caso, su nombre. Además, se ha añadido una función llamada “caps” para

que, en el caso de que el usuario introduzca su nombre en minúsculas, la interfaz convierta

automáticamente sus letras a mayúsculas.

Por otra parte, se han insertado cinco botones en la GUI mediante el elemento “Button” de Tkinter,

los cuales son los siguientes:

botónBorrar: Al pulsarse, se encarga de borrar el texto introducido en la caja de texto creada

para introducir el nombre del usuario, permitiendo a este poder corregir errores de escritura.

Memoria

94

botónSalir: Al pulsarse, cierra la ventana de la GUI de la aplicación.

botónCámara: Al pulsarse, se abre la cámara para que el usuario pueda observar desde un

ángulo superior cómo el robot forma su nombre. Para cerrar la ventana, es necesario pulsar la

tecla ‘1’ y darle a la cruz que aparece en la parte superior derecha.

botónStop: Al pulsarse, se envía una cadena de la interfaz al robot haciendo que este se

detenga inmediatamente. Este botón no ha llegado a programarse, pero queda añadido en el

diseño de la interfaz para una futura función.

botónAceptar: Es el botón principal de la interfaz ya que, al pulsarse, se encarga de iniciar el

funcionamiento de la aplicación. Una vez pulsado, primeramente, se encarga de inhabilitar

tanto la caja de texto como él mismo, con el objetivo de que el usuario no pueda volver a

introducir otro nombre hasta la finalización de la formación del nombre ya introducido.

Seguidamente, se realizan las siguientes tareas:

o Lectura del nombre introducido y separación del mismo en sus distintas letras,

contando el número necesario de cada una para su formación.

o Captura de la imagen mediante la cámara, preprocesamiento y extracción de ROIs.

o Reconocimiento de letras, inclinación, rotación, coordenada X y coordenada Y

respecto al sistema de referencia del robot.

Una vez realizadas estas tareas, se realiza una comparación entre las letras necesarias para la

formación del nombre introducido por el usuario y las letras reconocidas en la captura tomada

por la cámara. De esta manera, pueden suceder dos cosas:

o No es posible la formación del nombre debido a que no se han reconocido en la

imagen las letras necesarias. En este caso, la interfaz se encarga de avisar al usuario

mediante una ventana emergente (“messagebox”) y le pide que ponga sobre el

tablero las letras necesarias.

Fig. 8.3. Ventana emergente de falta de letras.


95

o Es posible la formación del nombre debido a que se han reconocido en la imagen, al

menos, las letras necesarias. En este caso, la interfaz avisa al usuario mediante una

ventana emergente de que observa al robot formar el nombre y, además, se encarga

de llevar a cabo una comunicación por puerto RS-232 con el robot, enviando los datos

necesarios para la colocación del nombre.

Fig. 8.4. Ventana emergente formación del nombre.

Finalmente, se ha añadido el título del TFG, el logo de la Escuela de Ingeniería de Barcelona Este (EEBE),

una imagen de uno de los cubos utilizados, y se ha establecido una imagen del brazo robótico RV-2AJ

como icono de la ventana de la aplicación.

El aspecto final de la interfaz gráfica de usuario se puede observar en la Figura 8.5.

Fig. 8.5. GUI de la aplicación.

Memoria

96

8.1.2. Comunicación por puerto serie RS-232

La programación de la comunicación por puerto serie se ha realizado mediante la librería pySerial de

Python, la cual dispone de funciones para la lectura y el envío de datos para establecer la comunicación

entre la interfaz y el robot. En concreto, el protocolo de comunicación se establece únicamente para

el caso en el que es posible la formación del nombre del usuario, ya que en caso contrario no es

necesaria la comunicación con el robot.

Inicialmente, una vez que se ha comprobado que es posible la formación del nombre en la GUI, esta

envía al robot la cadena “STGUI” para la preparación del robot para recibir datos, de manera que, al

recibirlo, el controlador del robot envía a la interfaz la cadena “STROB”. A continuación, se procede a

enviar los datos de posición de la primera letra (coordenada X e Y), inclinación y rotación al robot y se

espera que este envíe la cadena “READY” a la interfaz para proceder a enviar los datos de la siguiente

letra.

Una vez que se han colocado todas las letras del nombre y el controlador del robot le ha enviado la

última cadena “READY” a la interfaz, esta le envía al robot la cadena “FIGUI” y seguidamente el

controlador le devuelve a la interfaz la cadena “FIROB”, finalizando la formación del nombre del

usuario.

En la Figura 8.6. se muestra el diagrama de flujo del protocolo de comunicación por puerto serie

implementado en la aplicación.

Fig. 8.6. Comunicación por puerto serie RS-232.


97

El código final de la programación de la GUI con Python se puede encontrar en el Anexo A5 de este

documento.

8.2. Programación del robot RV-2AJ

El último paso para la finalización de esta aplicación demostrativa es la programación del robot RV-2AJ,

la cual se ha realizado en lenguaje MELFA BASIC IV mediante el programa RT Toolbox 2. Básicamente,

esta programación consiste en una rutina “Pick&Place” donde el robot procede a recoger los distintos

cubos necesarios a las posiciones enviadas por puerto serie desde la interfaz y los coloca

adecuadamente en el soporte para llevar a cabo la formación del nombre del usuario.

Es necesario tener en cuenta que la posición del extremo del robot queda definida por 6 datos, de los

cuales 3 se refieren a posición y los otros 3 definen la orientación:

Coordenada X.

Coordenada Y.

Coordenada Z.

Orientación A.

Orientación B (fija).

Orientación C (fija y nula).

Concretamente, la programación comienza posicionando el extremo del robot en una posición inicial

definida como (X, Y, Z, A, B, C) = (159.37, -5.89, 481.23, 0, 180, 0), abriendo la pinza y estableciendo la

velocidad al 100%. Seguidamente, se procede a leer los datos enviados por puerto serie desde la GUI,

existiendo tres posibilidades:

Se recibe “STGUI”, entonces el controlador del robot envía inmediatamente “STROB”.

Se recibe “FIGUI”, entonces el controlador del robot envía inmediatamente “FIROB”.

Se recibe una cadena de 4 datos: coordenada X (MX), coordenada Y (MY), inclinación (ALFA) y

orientación (BETA). Entonces el robot procede a llevar a cabo la rutina de recoger el cubo del

tablero y colocarlo sobre el soporte. Una vez colocado correctamente, el controlador envía la

cadena “READY” a la GUI.

En la Figura 8.7. se muestra el diagrama de flujo de la programación implementada para el brazo

robótico, pudiendo observar la lectura de los datos enviados por puerto serie y la rutina de

“Pick&Place” llevada a cabo en la rama central.

Memoria

98

Fig. 8.7. Diagrama de Flujo programación robot.

Se puede observar que la coordenada Z de los cubos situados en el tablero queda definida a 108,

haciendo una posición intermedia a 50 mm más arriba para reducir la velocidad del robot al 50% e

impedir colisiones.

Respecto la posición final, con el objetivo de que no sea necesario enseñar al robot todas las posiciones

a lo largo del soporte diseñado para colocar las piezas, se comprueba en el diagrama que se procede a

utilizar la posición (X, Y, Z) = (-99, - 382, 210) como una situación de paso para la colocación de la pieza,

correspondiente a una posición cercana al extremo del soporte. Seguidamente, se mueve 50 mm en

el eje X con el objetivo de soltar la pieza encima del soporte. Cabe decir que, al ir colocando las distintas

letras, este movimiento en el eje X provoca también el movimiento de las piezas ya colocadas en el

soporte, desplazándose hacia la izquierda formando finalmente el nombre del usuario.


99

En la Figura 8.8. se muestra de manera ilustrativa la manera en que el robot coloca el nombre de Ángel

en el soporte, siendo necesario definir solamente las posiciones de color rojo.

Fig. 8.8. Colocación de cubos en el soporte.

De esta manera, queda definida también la programación del brazo robótico para poder llevar a cabo

correctamente la aplicación demostrativa de robótica industrial y visión por computador, finalizando

este capítulo de implementación de la aplicación.

En el Anexo A6 se puede encontrar la programación MELFA BASIC IV realizada para el funcionamiento

de la aplicación.

Memoria

100

9. Presupuesto y análisis económico

En este capítulo se muestran detalladamente los costes asociados a este proyecto. Los costes

principales son los de personal, debido a que la mayoría de tareas requieren de una gran cantidad de

horas de trabajo y estudio, aunque también ha sido necesaria la compra de material.

9.1. Costes de personal

CONCEPTO CANTIDAD DE

HORAS

COSTE HORA COSTE TOTAL

Aprendizaje

previo

100 h 0 €/h 0 €

Adquisición de

datos

reconocimiento y

orientación

20 h 20 €/h 400€

Adquisición de

datos localización

30h 20 €/h 600 €

Tratamiento de

datos

70 h 20 €/h 1400 €

Diseño e

implementación

de experimentos

100 h 20 €/h 2000 €

Diseño de

interfaz gráfica

de usuario (GUI)

50 h 20 €/h 1000 €

Tareas de

programación

Python

110 h 20 €/h 2200 €


101

Tareas de

programación

MELFA

40 h 20 €/h 800 €

Obtención y

análisis de los

resultados

100 h 20 €/h 2000 €

Redacción de la

memoria

120 h 20 €/h 2400 €

TOTAL 12800 €

9.2. Costes de material

CONCEPTO COSTE UNIDAD UNIDADES COSTE TOTAL

Soporte para la

colocación de la

cámara

15,99 € 1 15,99 €

Pack letras

adhesivas

8,95 € 2 17,90 €

TOTAL 33,89 €

Cabe destacar que las herramientas y tecnologías utilizadas no generan ningún coste adicional de

licencias, dado que Python y sus librerías son libres y la licencia de RT Toolbox 2 ha sido proporcionada

por la universidad.

Memoria

102

10. Conclusiones

El objetivo inicial de este TFG era la mejora de la aplicación de robótica Alphabot añadiendo aspectos

de visión por computador, pudiendo ser mostrada la aplicación resultante durando las jornadas de

puertas abiertas de la EEBE. A pesar de que se planteaba como un proyecto a largo plazo, en general,

se considera que se han podido llevar a cabo la mayoría de procedimientos para lograr la

implementación final de la aplicación.

En primer lugar, se puede confirmar que los aspectos relacionados con la visión por computador y la

inteligencia artificial han sido resueltos en su totalidad, consiguiendo el reconocimiento de letras, su

orientación y su posición. Para solucionar esta parte se han necesitado una gran cantidad de horas de

aprendizaje para comprender las redes CNN, los algoritmos de regresión utilizados y los

procedimientos para llevar a cabo el preproceso de la imagen capturada.

En segundo lugar, se da por solucionado el correcto funcionamiento de la interfaz gráfica de usuario

(GUI) diseñada para la aplicación. De esta manera, el usuario puede introducir su nombre por teclado

en ella y, seguidamente, la GUI consigue enviar los datos de localización y orientación de las letras

presentes en la imagen al robot mediante comunicación RS-232.

Por último, ha sido realizada la programación del robot Mitsubishi RV-2AJ para llevar a cabo la

colocación ordenada de los distintos cubos hasta formar el nombre introducido por el usuario,

logrando también la comunicación con la interfaz de Python. A pesar de que la programación en MELFA

BASIC IV ya había sido introducida en la asignatura de Robótica Industrial y Visión por Computador

(RIVC), ha sido necesario un cierto aprendizaje para llevar a cabo la lectura por puerto serie de los datos

y la realización de los movimientos del robot en función de estos datos.

En conclusión, en este TFG se ha podido observar la multitud de tareas necesarias para implementar

una aplicación de tal envergadura a pesar del tiempo disponible. Cabe decir que se ha podido

comprobar la parte de visión por computador e inteligencia artificial realizando distintas pruebas

formando diferentes nombres. Sin embargo, a causa de las circunstancias actuales debidas al Covid-

19, no ha sido posible comprobar el funcionamiento de la programación del brazo robótico.


103

Trabajo futuro

A pesar de que se considera bastante finalizada la aplicación demostrativa realizada en este TFG,

existen una serie de trabajos que no se han podido realizar debido a las circunstancias mencionadas,

siendo imposible acceder al laboratorio donde se encuentra el robot en los últimos meses. Con el

objetivo de mejorar y completar esta aplicación, se proponen los siguientes trabajos:

Debido al uso de Deep Learning en el reconocimiento de letras, era necesario un número

elevado de imágenes para conseguir el correcto funcionamiento de la red, por lo que se

procedió a utilizar imágenes del conjunto de datos Chars74k. Sin embargo, sería interesante

añadir imágenes de las letras reales utilizadas en la aplicación y realizar un entrenamiento para

conseguir una precisión aún mejor.

Realización de pruebas del protocolo de comunicación RS-232 (ya programado) entre la

interfaz del ordenador y el robot Mitsubishi RV-2AJ, con el objetivo de realizar una prueba de

la aplicación completa.

Programar el botón de STOP insertado en la GUI, con el objetivo de poder detener

inmediatamente el robot ante situaciones de emergencia.

En este proyecto, el robot solamente tiene en cuenta las letras situadas en la cara frontal de

los cubos, esto es debido a que los grados de libertad del robot utilizado no le permiten rotar

estos cubos para encontrar las letras situadas en sus otros lados. Sin embargo, un objetivo

mayor para solucionar este problema sería la implementación una especie de cuña donde el

robot pueda dejar caer la pieza y que esta gire hacia la letra situada en su siguiente lado,

pudiendo llevar a cabo una especie de clasificación de los tipos de cubos. De esta manera, si

se necesita una letra que no está en la cara frontal de ningún cubo, el robot puede buscar

alguna otra letra de su respectivo grupo y dejar caer el cubo sobre la cuña hasta encontrar la

letra deseada, logrando un objetivo mayor que no ha sido posible cumplir.

Memoria

104

Bibliografía

[1] NationalMuseumsScotland, 26 septiembre de 2017. Alphabot at the National Museum of Scotland.

[última consulta: 5 diciembre 2019]. Disponible en: https://www.youtube.com/watch?v=zEyJsjGaWEs

[2] Antonio Barrientos, Luis Felipe Peñin, Carlos Balaguer, Rafael Aracil Santoja. Fundamentos de

robótica (2ª Ed). S.A. McGraw Hill, 2007.

[3] Carlos Trilnick. 4000-pound Unimate. [última consulta: 5 diciembre 2019]. Disponible en:

https://proyectoidis.org/4000-pound-unimate/

[4] MOTAT. Industrial Robot [IRB6, ASEA]. [última consulta: 6 diciembre de 2019]. Disponible en:

https://collection.motat.org.nz/objects/104032

[5] KUKA. La historia de KUKA. [última consulta: 6 diciembre 2019]. Disponible en:

https://www.kuka.com/es-es/acerca-de-kuka/historia

[6] Wikipedia. Robot PUMA. [última consulta: 6 diciembre 2019]. Disponible en:

https://es.wikipedia.org/wiki/PUMA_(robot)

[7] Origen de los robots. [última consulta: 7 diciembre 2019]. Disponible en:

https://www.timetoast.com/timelines/origen-de-los-robots

[8] Apuntes de RIVC Visión por Computador T2: La imagen digital. Disponible en campus virtual Atenea

UPC.

[9] Gerard Escudero Bakx, Samir Kanaan Izquierdo. Apuntes de IAAE. Disponible en campus virtual

Atena UPC.

[10] Jordi Torres. Deep Learning: Introducción práctica con Keras (Primera Parte) (3ª Ed). Watch this

Space-Barcelona, junio 2018.

[11] Qué es overfitting y underfitting y cómo solucionarlo. [última consulta: 20 enero de 2020].

Disponible en: https://www.aprendemachinelearning.com/que-es-overfitting-y-underfitting-y-como-

solucionarlo/

[12] John Germán Vera Luzuriaga, enero 2017. Control de trayectoria de la simulación de un brazo robot

de 5 grados de libertad, controlado mediante la plataforma C2000 Piccolo LAUNCHXL-F28027F. [última

consulta: 10 diciembre 2019]. Disponible en:

https://riunet.upv.es/bitstream/handle/10251/79512/VERA%20%20Control%20de%20trayectoria%2

0de%20la%20simulaci%C3%B3n%20de%20un%20brazo%20robot%20de%205%20grados%20de%20li

bertad%2C%20control....pdf?sequence=1&isAllowed=y

https://www.youtube.com/watch?v=zEyJsjGaWEs

https://proyectoidis.org/4000-pound-unimate/

https://collection.motat.org.nz/objects/104032

https://www.kuka.com/es-es/acerca-de-kuka/historia

https://es.wikipedia.org/wiki/PUMA_(robot)

https://www.timetoast.com/timelines/origen-de-los-robots

https://www.aprendemachinelearning.com/que-es-overfitting-y-underfitting-y-como-solucionarlo/

https://www.aprendemachinelearning.com/que-es-overfitting-y-underfitting-y-como-solucionarlo/

https://riunet.upv.es/bitstream/handle/10251/79512/VERA%20%20Control%20de%20trayectoria%20de%20la%20simulaci%C3%B3n%20de%20un%20brazo%20robot%20de%205%20grados%20de%20libertad%2C%20control....pdf?sequence=1&isAllowed=y




105

[13] Mitsubishi Electric. Mitsubishi Industrial Robots: RV-1A/RV-2-AJ Series Standard Specifications

Manual. [última consulta: 25 octubre 2019]. Disponible en:

http://suport.siriustrading.ro/02.DocArh/07.RI/03.Seria%20RV%20(Vertical)/03.RV-

A/02.Manuale/RV-1A,2AJ%20-%20Standard%20Specifications%20Manual%20BFP-A8050-

K%20(09.09).pdf

[14] Mitsubishi Electric. MELFA Industrial Robots: Instruction Manual Controller CR1571. [última

consulta: 27 octubre 2019]. Disponible en: https://www.unisgroup.nl/pdf/EN/Mitsubishi-CR1-

Manual.pdf

[15] Sebastián Tornil Sin, febrero de 2019. Apuntes de RIVC T5: Programación de robots. Disponible en

campus virtual Atenea UPC.

[16] Frecuencia de aparición de letras. [última consulta: 2 de octubre de 2019]. Disponible en:

https://es.wikipedia.org/wiki/Frecuencia_de_aparici%C3%B3n_de_letras

[17] Joe Minichino Joseph Howse. Learning OpenCV 3 Computer Vision with Python (2ª Ed). Packt

Publishing Ltd, septiembre 2015.

[18] Alejandro Suárez Lamadrid, Antonio Suárez Jiménez. Fundamentos para procesar imágenes con

Pillow (I). [última consulta: 5 noviembre 2019]. Disponible en: https://python-para-

impacientes.blogspot.com/2014/12/fundamentos-para-procesar-imagenes-con.html

[19] Alexander Mordvintsev, Abid K. Image Processing in OpenCV: Image Thresholding. [última

consulta: 25 octubre 2019]. Disponible en:

https://docs.opencv.org/3.4/d7/d4d/tutorial_py_thresholding.html

[20] Gl4r3, 2017. Tutorial de OpenCV + Python: tracking de objetos con el método de Lucas Kanade.

[última consulta: 20 noviembre 2019]. Disponible en: https://robologs.net/2017/08/22/tutorial-de-

opencv-python-tracking-de-objetos-con-el-metodo-de-lucas-kanade/

[21] T.E. de Campos, B.R. Barbu, M. Varma. The Chars74K dataset. Character Recognition in Natural

Images. Febrero 2009. [última consulta: 30 septiembre 2019]. Disponible en:

http://www.ee.surrey.ac.uk/CVSSP/demos/chars74k/

[22] Aurélien Géron. Hands-On Machine Learning with Scikit-Learn & TensorFlow: concepts, tools and

techniques to build intelligent systems (1ª Ed). O’Reilly Media, marzo 2017.

[23] Lecun et al. Gradient-Based Learning Applied to Document Recognition. [última consulta: 15 enero

de 2020]. Disponible en: http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf

http://suport.siriustrading.ro/02.DocArh/07.RI/03.Seria%20RV%20(Vertical)/03.RV-A/02.Manuale/RV-1A,2AJ%20-%20Standard%20Specifications%20Manual%20BFP-A8050-K%20(09.09).pdf



https://www.unisgroup.nl/pdf/EN/Mitsubishi-CR1-Manual.pdf

https://www.unisgroup.nl/pdf/EN/Mitsubishi-CR1-Manual.pdf

https://es.wikipedia.org/wiki/Frecuencia_de_aparici%C3%B3n_de_letras

https://python-para-impacientes.blogspot.com/2014/12/fundamentos-para-procesar-imagenes-con.html

https://python-para-impacientes.blogspot.com/2014/12/fundamentos-para-procesar-imagenes-con.html

https://docs.opencv.org/3.4/d7/d4d/tutorial_py_thresholding.html

https://robologs.net/2017/08/22/tutorial-de-opencv-python-tracking-de-objetos-con-el-metodo-de-lucas-kanade/

https://robologs.net/2017/08/22/tutorial-de-opencv-python-tracking-de-objetos-con-el-metodo-de-lucas-kanade/

http://www.ee.surrey.ac.uk/CVSSP/demos/chars74k/

http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf

Memoria

106

Anexos

A1. Código Python Modelos de regresión


107

A2. Código Python CNN Reconocimiento de letras

Memoria

108


109

Memoria

110

A3. Código Python detección del ángulo de inclinación de las ROIs


111

Memoria

112

A4. Código Python CNN reconocimiento letras rotadas


113

Memoria

114


115

A5. Código de la interfaz de la aplicación

Memoria

116


117

Memoria

118


119

Memoria

120


121

Memoria

122

A6. Programación MELFA robot


123

aplicaciÓn demostrativa de robÓtica industrial y …

Documents