Reporte final de Servicio Social

Proyecto: Visión artificial con una Raspberry Pi, con el objetivo de obtener el tiempo de respuesta
al ejecutar algoritmos basados en operadores morfológicos y la transformada de Hough para el
reconocimiento de objetos.

Profesor:
M. C Felipe Santiago Espinosa

Alumnos:
Antonio Madera Abisai
García Pacho Jorge Simei

Carrera:
Ingeniería en Mecatrónica

Fecha:
08 de Septiembre de 2021

Huajuapan de León, Oaxaca

Contenido
¿Qué es Python?......................................................................................................................3
¿Qué es Open CV?..................................................................................................................3
¿Qué es una Raspberry Pi?......................................................................................................3
¿Qué es visión artificial?.........................................................................................................4
Tipos de sistemas de visión artificial industrial..................................................................5
Sensores de visión...........................................................................................................5
Cámaras inteligentes y sistemas de visión integrados....................................................5
Sistemas de visión avanzados.........................................................................................6
Aplicaciones de los sistemas de visión artificial.................................................................6
¿Cómo instalar Python y Open CV en la Raspberry?.............................................................6
Instalación de Python en Raspberry....................................................................................7
Instalación de Open CV en Raspberry................................................................................8
Detección de círculos por medio del Algoritmo basado en Operadores morfológicos........10
Erosión...............................................................................................................................10
Dilatación..........................................................................................................................10
Apertura.............................................................................................................................11
Cierre.................................................................................................................................11
Gradiente Morfológico......................................................................................................11
Detección de círculos por medio del Algoritmo basado en la Transformada de Hough......12
Implementación en la Raspberry Pi......................................................................................14
Resultados.............................................................................................................................14
Usando algoritmo basado en operadores morfológicos....................................................14
Usando algoritmo basado en la transformada de Hough...................................................15
Conclusión............................................................................................................................16
Anexos (Código, Imágenes del prototipo)............................................................................16
Bibliografía...........................................................................................................................17
¿Qué es Python?
Python es un lenguaje de programación de alto nivel, orientado a objetos, con una
semántica dinámica integrada, principalmente para el desarrollo web y de aplicaciones
informáticas. Este soporta el uso de módulos y paquetes, lo que significa que los programas
pueden ser diseñados en un estilo modular y el código puede ser reutilizado en varios
proyectos. Una vez se ha desarrollado un módulo o paquete, se puede escalar para su uso en
otros proyectos, y es fácil de importar o exportar (aula21, SF).
Python contiene implícitas algunas estructuras de datos como listas, diccionarios, conjuntos
y tuplas, que permiten realizar algunas tareas complejas en pocas líneas de código y de
manera legible. Fue basado en el lenguaje ABC y se dice que fue influenciado por otros
como C, Algol 60, Modula-3 e Icon (Challenger et al., 2014).

¿Qué es Open CV?

OpenCV fue lanzado oficialmente en 1999, el proyecto inicialmente fue una iniciativa de
investigación del Intel para avanzar en la CPU aplicaciones de uso intensivo, que forma
parte de una serie de proyectos, entre ellos en tiempo real el trazado de rayos y las paredes
de visualización 3D (Mogena, SF).
Open CV es una librería que proporciona un marco de trabajo de alto nivel para el
desarrollo de aplicaciones de visión por computador en tiempo real: estructuras de datos,
procesamiento y análisis de imágenes, análisis estructural, etc. (Arévalo, 2003)
Así mismo, Arévalo et al. explica que esta librería es una API de aproximadamente 300
funciones escritas en lenguaje C que se caracterizan por los siguientes puntos:

 Su uso es libre tanto para su uso comercial como no comercial.

 No utiliza librerías numéricas externas, aunque puede hacer uso de alguna de ellas,
si están disponibles, en tiempo de ejecución.
 Es compatible con The Intel® Processing Library (IPL) y utiliza The Intel®
Integrated Performance Primitives(IPP) para mejorar su rendimiento, si están
disponibles en el sistema.
 Dispone de interfaces para algunos otros lenguajes y entornos: EiC - intérprete
ANSI C escrito por Ed Breen. Hawk y CvEnv son entornos interactivos (escritos en
MFC y TCL, respectivamente) que utilizan el intérprete EiC; Ch - intérprete ANSI
C/C++ creado y soportado por la compañía SoftIntegration; Matlab® - gran entorno
para el cálculo numérico y simbólico creado por Mathworks; y muchos más.

¿Qué es una Raspberry Pi?

La Raspberry Pi fue creado en el año 2006; es un pequeño ordenador del tamaño de una
tarjeta de crédito que cumple con muchas de las funciones de un ordenador normal. Este
fue diseñado principalmente para disminuir el costo en las instalaciones educativas y para
que personas de bajos recursos puedan tener acceso a la tecnología informática. En la base,
que es una placa, está montado un procesador, una memoria RAM, y un chip gráfico. Así
mismo, cuenta con 40 pines GPIO (pines de entrada y salida), estos se pueden controlar por
el usuario en tiempo de ejecución y un conector para cámara, lo único que no tiene es cable
de alimentación ni el disco duro para ello se reemplaza por una memoria USB (Escalante et
al., 2019). Además, consta de puertos como USB, HDMI y Ethernet incluyendo así mismo
en algunos, el módulo wifi y bluetooth (Solectro, SF).

Esta tarjeta tiene un software de open source, que significa “código abierto”, por lo que se
puede ser modificado a través de un programador y puede trabajarse en cualquier sistema
operativo incluso en últimas versiones de Windows (Escalante et al., 2019).

¿Qué es visión artificial?

La visión artificial es una

disciplina científica que incluye
métodos para adquirir, procesar
y analizar imágenes del mundo
real con el fin de producir
información que pueda ser
tratada por una máquina.
Una manera simple de
comprender este sistema es
Figura 1.- Visión artificial por medio de un
KinectV2 y Open CV basarnos en nuestros propios
sentidos. Los humanos usamos
nuestros ojos para comprender el mundo que nos rodea, y la visión artificial trata de
producir ese mismo efecto en máquinas.  Éstas podrán percibir y entender una imagen o
secuencia de imágenes y actuar según convenga en una determinada situación. La
comprensión en los dispositivos se consigue gracias a una descomposición de la imagen en
pequeños fragmentos (píxeles) y en su posterior estudio.
La principal finalidad de la visión artificial es dotar a la máquina de “ojos” para ver lo que
ocurre en el mundo real, y así poder tomar decisiones para automatizar cualquier proceso.
(contaval, 2016).
El procesamiento de estas imágenes con los softwares que llevan instalados los sistemas y
cámaras visión artificial tienen el objetivo de producir información que las máquinas
automatizadas pueden emplear y corregir posibles errores en las líneas de montaje.
De esta manera, son los sistemas de visión artificial aplicados a la robótica los que se
encargan de realizar procesos de inspección de muestreo, supervisión y controles de
calidad, eximiendo a los empleados de realizar tareas repetitivas y donde existe más margen
de error y menos exactitud analítica que la que ofrece el procesamiento de una imagen.
Por tanto, la base de la visión artificial consiste en el empleo de imágenes captadas por los
sistemas de visión, que son procesados por el software que lleva el mismo sistema y, con
todo ello, medir, contar, seleccionar o identificar anomalías o productos defectuosos.
Según el procesamiento de estos datos, el sistema robotizado puede tomar decisiones
automatizadas e inteligentes para revertir los errores, desechar productos y todo ello,
siguiendo los parámetros con los que el sistema ha sido programado.

Tipos de sistemas de visión artificial industrial

Aunque los límites entre las tipologías de productos de visión artificial estén muy poco
definidos, podemos hablar de diversas categorías y destacar algunas características
relevantes de cada una de ellas:
Sensores de visión

Se trata de una tecnología de visión más sofisticada que los tradicionales sensores

fotoeléctricos, aunque sus limitaciones en la toma de decisiones son más significativas que
en el caso del resto de productos conectados a un software, por lo que sus tareas se limitan
más a detectar resultados de paso o fallo.
Su ventaja es que la integración y puesta en marcha en muy sencilla y rápida, tanto por su
tamaño reducido, como por el coste de la tecnología y su potencia de cálculo más
moderada.
Cámaras inteligentes y sistemas de visión integrados

Son la tecnología más avanzada en relación a sensores de visión y destacan por su potencia
de cálculo capaz de dar solución a cualquier necesidad de visión industrial-, resolución de
imagen y fácil instalación. Esto facilita que sus aplicaciones sean muy variadas, sin
importar actividad o fase de la cadena de producción. Su aspecto más innovador reside en
su capacidad de procesamiento, que le dota de almacenamiento y disponibilidad para
conectar con otros sistemas automatizados, gracias a los mecanismos de entrada y salida.
En el caso de los sistemas de visión integrados, el sensor y la memoria de la cámara se
ubican en un cabezal remoto de tamaño muy reducido. El procesador también se ubica en
remoto, facilitando la conectividad y manejo de los elementos.
Sistemas de visión avanzados

Son muy similares a los sistemas de visión integrados, pero cuentan con un hardware más
sofisticado y completo, lo que mejora las funciones relacionadas con el software y
procesamiento de datos. Su aplicación está ideada para tecnologías y máquinas
automatizadas de mayor complejidad, por lo que en muchas ocasiones se requiere que este
sistema sea implementado durante la fabricación de la maquinaria.

Aplicaciones de los sistemas de visión artificial

Las aplicaciones de los sistemas de visión artificial industrial son muy variadas y

adaptables a cada sector, tipo de actividad y necesidades de la línea de producción. En el
caso de la automación, son de gran utilidad
para la inspección de piezas y el ensamblaje
de estas. La industria alimentaria alaba esta
forma de automatización industrial porque
mejora y agiliza los controles de calidad en
cada etapa (infaimon, 2019).

Figura 2.- Cámaras de visión

artificial

¿Cómo instalar Python y Open CV en la Raspberry?

Una vez que se ha definido lo que es Python y open CV, es necesario que se instalen en
nuestra Raspberry PI. Para esto, es necesario conectar nuestra tarjeta por medio del cable
HDMI a un monitor externo y conectar a los puertos USB un mouse y un teclado; estos nos
ayudarán a poder controlar por medio de la interfaz gráfica de sistema operativo Raspbian
(recomendado para la Raspberry). Una vez hecho estas conexiones, alimentamos nuestro
sistema con su eliminador correspondiente y se iniciará como cuando se inicia una
computadora con un sistema operativo como Windows.

Una vez iniciado el sistema, debemos presionar en la parte superior izquierda el símbolo
del sistema raspbian y buscar el terminal. Toda instalación se hará a través de esta forma
por medio de comandos que en breve se describirán (véase figura a).

Figura a.- Terminal en Raspbian Os

Instalación de Python en Raspberry

Lo primero que tenemos que verificar es qué versión de Python tenemos en nuestro
sistema, de entrada, Raspbian ya tiene una versión instalada (del Valle, 2021). Para
verificar lo mencionado, digitamos python3 en la terminal y presionamos <enter>, se
desplegará lo siguiente (véase figura b):

Figura b.- Versión instalada de Python

Ahora, es necesario instalar unos prerrequisitos del sistema, por lo que, en la misma
terminal, ingresaremos las siguientes líneas de código. Nota: Se pueden copiar y pegar:
sudo apt-get update
sudo apt-get install build-essential tk-dev libncurses5-dev libncursesw5-dev libreadline6-
dev libdb5.3-dev libgdbm-dev libsqlite3-dev libssl-dev libbz2-dev libexpat1-dev liblzma-dev
zlib1g-dev

Estas órdenes instalarán las librerías necesarias para la instalación de Python 3.6.0 en
nuestro sistema Raspbian de nuestra Raspberry PI. El segundo paso es descargar Python
3.6.0 de la web oficial (https://www.python.org/ftp/python/3.6.0 ... 6.0.tar.xz) o bien desde
la terminal (crearemos el directorio /home/pi/python-3.6.0), nos colocamos en este
directorio desde la terminal y ejecutamos la siguiente instrucción:

cd /tmp
wget https://www.python.org/ftp/python/3.6.0/Python-3.6.0.tar.xz
sudo tar xf Python-3.6.0.tar.xz
sudo su
cd Python-3.6.0
sudo ./configure && make && make altinstal

Las líneas de código anteriores lo que harán es descargar Python e instalarlo, deben ser
ejecutado línea a línea. Para comprobar la instalación, digitaremos python3.6 –version en
la terminal del sistema. El mensaje que debe devolvernos es Python 3.6.0. Listo, hemos
instalado Python en Raspberry PI.

Instalación de Open CV en Raspberry

Previo a la instalación de OpenCV en python 3 (Solano, 2020), necesitamos instalar
algunos paquetes (véase figura c), esto lo haremos a través de la siguiente línea:

sudo apt-get install libhdf5-dev libhdf5-serial-dev libatlas-base-dev libjasper-dev

libqtgui4 libqt4-test

Figura c.- Instalando paquetes necesarios

Una vez instalados los paquetes necesarios, ahora vamos a instalar la versión de OpenCV
4.1.0.25. Debemos decir que se hizo pruebas con otras versiones, pero se tenía dificultades
al instalarlas debido a paquetes faltantes, sin embargo, buscando información con la versión
4.1.0.25 se tuvo muy buenos resultados. Usamos pip3 install opencv-contrib-python (véase
figura d), pero la línea de código a ingresar en la terminal es:
 pip3 install opencv-contrib-python==4.1.0.25

Figura d.- Instalando paquetes necesarios

En caso de que marque algún error porque no se encontró la versión, desplegará una lista de
versiones disponibles y volvemos a poner la misma línea de comando anterior y
posteriormente, cambiamos la versión 4.1.0.25 por alguna versión cercana disponible.
Para comprobar que se ha instalado OpenCV, digitamos python3 en el terminal e
importamos OpenCV para finalmente imprimir la versión instalada (véase figura e):

import cv2
cv2.__version__

Figura e.- Instalando paquetes necesarios

Una vez que se ha instalado open cv, vamos a verificar si ya podemos dar uso de las
librerías propias de Open CV. Por lo que agregamos el siguiente código a nuestro editor de
texto cualquiera y lo ejecutamos:
El código lo que haces, abrir una imagen y poder visualizarlo. Si queremos cambiar la
imagen a abrir, sólo sustituimos ‘ave.jpg’ por el nombre de nuestra imagen con su
extensión como png, jpg. Para nuestro caso, probamos el código mencionado y se ejecutó
sin errores, por lo que se comprueba que python y open cv están funcionando
correctamente.
Está todo listo para poder comenzar a trabajar con visión artificial con ayuda de python y
open cv.
 import cv2
imagen=cv2.imread(‘eve.jpg’)
cv2.imshow(‘Prueba’, imagen)
cv2.waitKey(0)
cv2.destroyAllWindows()

Detección de círculos por medio del Algoritmo basado en

Operadores morfológicos

Lo importante es definir primeramente qué es un operador morfológico. Por lo que a

continuación se mencionará y se clasificará.
Las transformaciones morfológicas son algunas operaciones simples basadas en la forma
de la imagen, que normalmente se aplican a imágenes binarias. Necesita dos entradas, una
es nuestra imagen original, la segunda se llama elemento
estructurante o núcleo (kernel) que decide la naturaleza de la
operación. Dos operadores morfológicos básicos son Erosión y
Dilatación. Luego, sus formas variantes como Apertura, Cierre,
Gradiente, etc., también entran en juego. A continuación, se verán
algunas de estas transformaciones, apoyándonos en la siguiente
imagen binaria (véase figura 1):
Figura 1.-Imagen binaria
de ejemplo
Erosión

Similar a la convolución 2D, en el proceso de erosionado un kernel se desliza a través de la

imagen. Un píxel de la imagen original (1 o 0) sólo se considerará 1 si todos los píxeles que
caen dentro de la ventana del kernel son 1, de lo contrario se erosiona (se hace a cero). Por
tanto, todos los píxeles cerca de los bordes de los objetos en la imagen serán descartados
dependiendo del tamaño del kernel. Como consecuencia, el grosor
o el tamaño de los objetos en primer plano disminuye o, en otras
palabras, la región blanca disminuye en la imagen. Se utiliza la
siguiente función cv2.erode(). Este procedimiento es útil para
eliminar pequeños ruidos blancos, separar dos objetos conectados,
etc. A continuación, un ejemplo donde se utiliza un kernel de 7×7
formado por unos (véase figura 2):
Dilatación
Figura 2.-Aplicación de
la erosión a la imagen El proceso de dilatación es justo lo opuesto a la erosión. Aquí, un
binaria elemento de píxel es ‘1’ si al menos un píxel de la imagen de los
que caen dentro de la ventana del kernel es ‘1’. Por lo tanto, la
dilatación aumenta el tamaño de los objetos de primer plano, es
decir, la región blanca. Normalmente, en casos como la
eliminación del ruido, la erosión es seguida de dilatación. La
razón para esto es que, aunque la erosión elimina los ruidos
blancos también encoge los objetos. Por tanto, para recuperar el
tamaño inicial, este se dilata. La transformación de dilatación
también es útil para unir partes rotas de un objeto. Se utiliza la Figura 3.-Aplicación de la
función cv2.dilate(). A continuación, un ejemplo de cómo la dilatación a la imagen
dilatación funciona (véase figura 3): binaria

Apertura

La apertura es simplemente otro nombre para erosión seguida de dilatación. Como se

explicó anteriormente, es útil para eliminar el ruido. En este caso se utiliza la
función, cv2.morphologyEx(). Vea el ejemplo a continuación (véase figura 4):
Cierre

El Cierre es el opuesto de Apertura, es decir, dilatación

Figura 4.- Aplicación de la
apertura a la imagen binaria
continuación (véase figura 5):
seguida de erosión. Es útil para cerrar pequeños agujeros
dentro de los objetos de primer
plano, o pequeños puntos negros
en el objeto. Vea un ejemplo a

Gradiente Morfológico Figura 5.- Aplicación del cierre a

la imagen binaria

Es la diferencia entre la dilatación y la erosión de una imagen. El resultado se verá como el

contorno del objeto (véase imagen 6).
En todos los ejemplos mostrados hemos creado manualmente
elementos estructurantes (kernels) de forma rectangular
(utilizando np.ones()). Sin embargo, en algunos casos, es
necesario crear núcleos elípticos / circulares.
Ya que hemos definido la clasificación de los operadores, vamos
a determinar, cuál es la secuencia de procesamiento que debe
seguir una imagen para que esté lista para la detección de los
círculos (Solectro). A continuación, se ilustra ese proceso (véase
Figura 6.- Aplicación del
gradiente morfológico a la
figura 7):
imagen binaria
 Figura 7.- Diagrama de flujo del procesamiento de imágenes.

Para el caso de nuestro proyecto, la imagen de entrada, será un video en la cual se visualiza
a dos objetos circulares (véase figura 7). La idea es que se pueda determinar la distancia
que hay entre un centro del otro objeto.

Figura 7.- Fotografía del video.

Observaciones de nuestra fotografía a analizar. Cabe resaltar que, puede ser tanto imagen
como video. Para nuestro caso, será un vídeo continuo, por lo que será necesario ir
guardando nuestro código en la misma carpeta para evitar posibles lecturas del mismo. La
razón por las cuales se ocupó un video, en vez de la proyección misma de la cámara, es
porque realizando pruebas nos dimos cuenta que la cámara no dispone de la suficiente
resolución para hacer la captura de imágenes y poder procesarlas. Al momento de correr
código, no detectaba nada, a esa distancia, se volvía borroso y por lo tanto indetectable, por
lo que se decidió continuar con un video capturado con un teléfono celular.

Detección de círculos por medio del Algoritmo basado en la

Transformada de Hough

Antes que nada, primero definamos qué es la transformada de Hough. La transformada de

Hough es uno de los métodos más comunes para detectar formas en el procesamiento
digital de imágenes; sin embargo, la complejidad computacional de la transformada es alta
si se realiza de forma secuencial (Canul et al., 2015). Esta transformada es una técnica
muy robusta frente al ruido y a la existencia de huecos en la frontera del objeto. A la hora
de aplicar la transformada de Hough a una imagen es necesario obtener primero una imagen
binaria de los píxeles que forman parte de la frontera del objeto (Área de Ingeniería de
Sistemas y Automática, 2005).
Existen una gran cantidad de usos aplicando la transformada de Hough tales como: poder
detectar simplemente puntos, líneas, detectar círculos aplicándolo para reconocer el rostro
de una persona, los ojos o alguna aplicación parecida, reconocer los bordes en una imagen
o en videos; aunque particularmente en este último es necesario tener ciclado el proceso.
Según lo explicado en Nava et al., el uso de algoritmos basado en la transformada de
Hough es de los más utilizados porque su aplicación es simple y rápida; ya que
primeramente se obtienen los bordes de la imagen y finalmente se traza un círculo de radio
r para cada punto de borde, tomando en cuenta el centro de la circunferencia.
Como ya se mencionaba anteriormente, realizar el proceso secuencial de la detección de
círculos costaría mucho recurso de la memoria RAM. Por lo tanto, para este trabajo se
utiliza la función cv2.HoughCircles, ya que la finalidad es poder hallar dos círculos en la
imagen y hallar la distancia que existe entre estos. Esta función nos permite ahorrarnos
tiempo de ejecución y de codificación y memoria RAM obteniendo muy buena eficiencia.
Los parámetros que se utilizan en esta función serían los siguientes:

 cv2.HoughCircles(img_gray_blurred, cv2.HOUGH_GRADIENT, resol,  px,  param

1, param2, minRadius, maxRadius)
a. img_gray_blurred: Esta parte recibe la imagen a detectar círculos; antes de ello
debe ser procesada la imagen original. Primero se recomienda usar
cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) donde img es la imagen original y nos
resultará una imagen en escala de grises. Después, aplicar un filtro pasa bajos, es
decir la imagen quedará borrosa eliminando la mayor cantidad de ruido posible con
el siguiente código cv2.blur(gray, (11, 11)), donde gray es el resultado del código
anterior y los valores 11 es cuanto filtro será aplicado; y este resultado final será el
img_gray_blurred.
b. cv2.HOUGH_GRADIENT: es una función fija para esta aplicación
c. resol: es la relación inversa de la resolución del acumulador. Así que, para evitar
problemas se recomienda usar el valor de 1 para que sea la misma resolución de la
imagen.
d. Px: distancia mínima (en pixeles) entre el centro y las circunferencias detectadas.
e. Param1: como se está utilizando cv2.HOUGH_GRADIENT es necesario declarar el
valor del umbral máximo en la detección de bordes Canny.
f. Param2: al igual que al anterior, este sería el valor del umbral mínimo en la
detección de bordes Canny.
g. minRadius: valor del radio mínimo de los círculos a detectar
 h. maxRadios: valor de radio máximo de los círculos a detectar

Implementación en la Raspberry Pi

Para la implementación de los dos algoritmos previamente mencionados, fue necesario dar
uso del módulo de una cámara de la
Raspberry Pi. Se armó una estructura
provisional que se utilizó para mantener
fija la cámara con vista superior. Nuestro
prototipo se muestra en la figura 8.
Como se observa en el prototipo
implementado, se ubicó la cámara web en
una tablita horizontal con vista hacia abajo,
por lo que la cámara visualizaba lo
siguiente (véase figura 9):
Figura 8.- Prototipo implementado

En los anexos, en la parte final de este

documento, se encontrará el código implementado
para cada método. Y en la siguiente sección, se
visualizarán los resultados.

Figura 9.- Vista de cámara de la

Raspberry PI

Resultados

Usando algoritmo basado en operadores morfológicos

A continuación, se muestran los resultados obtenidos de obtener el algoritmo basado en
operadores morfológicos.
 1 2 3

Figura 10.- Procesamiento de imágenes, paso a paso.

Usando algoritmo basado en la transformada de Hough

Las siguientes imágenes muestran el resultado obtenido usando la transformada de Hough

de la detención de los círculos. En la cuarta imagen solo se agrega el cálculo de la distancia.
Cabe mencionar que la transformada es para hallar los círculos de la imagen no el cálculo
de la distancia. Este último dependerá de cómo se defina la referencia del espacio de
trabajo; en este caso se utilizó una hoja tamaño carta.
Conclusión
Tiempo de ejecución
El tiempo que ocupó el algoritmo basado en operadores morfológicos en la raspberry pi fue
de 2.16 segundos mientras que con la transformada de Hough fue de
Eficiencia en resultado
¿Qué se logró?
Se obtuvo la implementación de los algoritmos en la raspberry mediante el uso de python y
open cv para la visión artificial, obteniendo buenos resultados y detectando que se debe
utilizar una mejor cámara, ésta debe tener mejor resolución.
Ideas para mejorar

 Optimización de código
 Implementación en plataforma real a utilizar
 Utilización de una cámara con mejor resolución
 Creación de una interfaz gráfica para su utilización
Bibliografía
Área de Ingeniería de Sistemas y Automática. (2005). Segmentación. Transformada de
Hough. Obtenido de http://www4.ujaen.es/~satorres/practicas/practica4_vc.pdf
Arévalo, V., González, J., & Ambrosio, G. (2003). LA LIBRERÍA DE VISIÓN ARTIFICIAL
OPENCV APLICACIÓN A LA DOCENCIA E INVESTIGACIÓN. España. Obtenido
de http://mapir.isa.uma.es/varevalo/drafts/arevalo2004lva1.pdf
aula21. (S.F.). aula21. Obtenido de Centro de información técnica para la industria:
https://www.cursosaula21.com/que-es-python/
Canul Arcero, L., López Martínez, J., & Narváez Díaz, L. (2015). Algoritmo rápido de la
transformada de Hough para detección de líneas rectas en una imagen. Yucatán,
México. Obtenido de
http://redi.uady.mx:8080/bitstream/handle/123456789/711/Algoritmo%20r
%C3%A1pido%20de%20la%20transformada%20de%20Hough%20para%20detecci
%C3%B3n%20de%20l%C3%ADneas%20rectas%20en%20una%20imagen.pdf?
sequence=1
Challenger Pérez, I., Diaz Ricardo, Y., & Becerra García, R. A. (2014). El lenguaje de
programación python. Ciencias Holguín, 14. Obtenido de
https://www.redalyc.org/pdf/1815/181531232001.pdf
contaval. (18 de Febrero de 2016). contaval. Obtenido de contaval:
https://www.contaval.es/que-es-la-vision-artificial-y-para-que-sirve/
del Valle Hernández, L. (Febrero de 2021). programarfacil.com. Obtenido de
https://programarfacil.com/blog/vision-artificial/opencv-raspberry-pi/
Escalante Cardoma, D. S., & Vargas Ospina, D. M. (2019). Raspberry pi: la tecnología
reducida en placa. Cali, Colombia. Obtenido de
https://repository.usc.edu.co/bitstream/handle/20.500.12421/4250/RASPBERRY
%20PI.pdf?sequence=3&isAllowed=y#:~:text=La%20Raspberry%20Pi%20es
%20un,acceso%20a%20la%20tecnolog%C3%ADa%20inform%C3%A1tica.
Infaimon. (28 de Octubre de 2019). infaimon.com. Obtenido de
https://blog.infaimon.com/sistemas-de-vision-artificial-tipos-aplicaciones/
Mogena Soler, A. (SF). Informe de OpenCV y Tratamiento de Imágenes. Obtenido de
http://www.informatica-juridica.com/wp-content/uploads/2014/01/Informe_OpenC
V_Tratamiento_Imagenes.pdf
Nava Acosta, A., Enríquez Aguilera, F., Cota Ruiz, J., Sin fuentes de la Hoya, E., & Rivas
Perea, P. (Octubre 2014). Detección de Círculos Basada en la Orientación de
Bordes y Triángulos Rectángulos. México.
Solano, G. (19 de Junio de 2020). OMES. Obtenido de omes-va.com:
https://omes-va.com/como-instalar-opencv-en-raspberry-pi/
Solectro. (SF). Curso de Raspberry Pi desde cero. Obtenido de
https://solectroshop.com/img/cms/Productos%20DICIEMBRE/Gu%C3%ADa
%20de%20Raspberry%20Pi%20desde%20cero%20-%20Solectro.pdf
Anexos (Código, Imágenes del prototipo)