FACULTAD DE INGENIERIA

ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS

INFORME ACADEMICO

“Titulo”

“Algoritmo Canny en la manipulación de las características de un objeto en el procesamiento

de imágenes”

Autor(es):

Azpilcueta Mendoza, Carlos

Marcatinco Pariona, Jean Pierre
Naupan Falcon Jose Alonso
Baltodano Quispe Carlos Javier
Holssen Jeffershon Maza Barrena
Gonzales Guillermo Julio Cesar

Asesor:

Jorge Isaac Necochea Chamorro

LIMA – PERÚ

2021
 ÍNDICE

I. Introducción 3
II. Marco teórico 4
III. Desarrollo 5
3.1 Canny algoritmo pasos 5
3.2 Pasos detallados del algoritmo 5
3.2.1 Procedimiento en escala de grises 5
3.2.2 Filtro suave gaussiano 5
3.2.3 Supresión no máxima 5
3.2.4 Detección de umbral doble 5
3.2.5 Suprimir puntos aislados de umbral bajo 5
IV. Algoritmo Cany 6
V. Conclusiones 7
VI. Referencias Bibliográficas 8
 I. INTRODUCCION

Es de prioridad la suma de mejorar las condiciones de las imágenes originales para

tener resultados decentes en cada una de las etapas. Una forma de contrarrestar
todos los problemas es bueno la resolución de las imágenes. Existen distintas formas
de hacerlo: el mismo dispositivo, es una forma bastante rápida y común, aunque
conlleva la suma de los costos del dispositivo sensor; otra manera es fabricar la
calidad de la imagen mediante un preprocesamiento de la misma. El tratamiento de
imágenes es un campo de la inteligencia computacional, que consiste en imitar la
cognición humana con el propósito de percibir electrónicamente una imagen digital por
ello existen muchas técnicas utilizadas para la restauración digital de imágenes, una
técnica muy utilizada en la fotografía es el mejoramiento de los bordes de la imagen.
Esta técnica conlleva en aislar los bordes de la imagen, amplificarlos y posteriormente
volverlos a poner en la imagen. Existen varios ediciones que se emplean para este
propósito, en resumen el tratamiento de imágenes tiene el objetivo principal de
resolver tareas complejas, para lo cual utiliza métodos o técnicas tales como captura
de imagen, digitalización, preprocesamiento, detección de bordes, segmentación de
regiones, clasificación de regiones, identificación de alto nivel, entre otros por lo cual
en los últimos años el Procesamiento Digital de Imágenes es muy esencial y utilizado
por diversas disciplinas las cuales son Medicina, Biología, Física e Ingeniería., donde
mediante este procesamiento es posible manipular imágenes digitales en una
computadora con el fin de obtener la información objetiva y útil.
En el área de procesamiento de imágenes, la detección de los bordes de una imagen
es de suma importancia y utilidad, pues facilita muchas tareas, entre ellas, la facilidad
de objetos, la segmentación de regiones, etc, donde al delimitar los objetos se definen
los límites entre ellos y el fondo. Las informaciones más útiles que se encuentran en
una imagen se encuentran en los y entre los propios objetos entre sí.
Existen diversas aplicaciones como reconocimiento facial, detección de monedas,
aunque el área más destacada es la medicina, en la que la detección de bordes realiza
un papel de gran importancia incorporando cada vez más y mejores avances en el
tratamiento de imágenes médicas, tales como quemaduras o tumores.
Gracias a estos avances los especialistas pueden obtener de una forma mucho más
rápida y precisa información sobre la zona a tratar y actuar en consecuencia.
La detección de bordes se basa en definir como borde a los píxeles donde la
intensidad de la imagen cambia de forma abrupta. Si consideramos una función de
intensidad de la imagen, entonces lo que buscamos son saltos en dicha función. La
idea básica detrás de cualquier detector de bordes es el cálculo de un operador local
de derivación
Para ello en el algoritmo realizado se ha utilizado el operador Canny. Este operador
está considerado como uno de los mejores para realizar la detección de bordes
mediante el empleo de máscaras de convolución y basado en la primera derivada. El
operador de detección de bordes de Canny fue desarrollado por un catedrático de la
universidad de Berkeley (EEUU) en 1986 y se basa en un algoritmo de múltiples fases
para detectar un amplio rango de bordes.
Es sin duda el operador más tomado en la detección de bordes. El objetivo de Canny
era descubrir el algoritmo óptimo para la detección de bordes. Un detector óptimo
significará una buena detección, el algoritmo debe marcar muchos bordes reales como
sea posible, una buena localización, los bordes marcados deben estar lo más cerca
posible del borde en la imagen real, y por último una mínima respuesta, es decir, un
borde dado debe ser marcado sólo una vez y donde sea posible el ruido presente en la
imagen no debería crear falsos bordes.
En términos históricos, las técnicas de procesamiento digital de imágenes surgieron de
modo relativamente tardío dentro de las áreas de aplicaciones informáticas. El motivo
principal de la demora son los requerimientos de hardware y sistemas gráficos de alta
performance. En modo paralelo, las metodologías teóricas y algoritmos de
procesamiento digital son relativamente elaborados y con alto grado de sofisticación.
Actualmente se cuenta con tecnología de hardware avanzada y se dispone de una
muy amplia variedad del Software, para procesamiento de las imágenes digitales. Se
aprovechan procedimientos desarrolladas originalmente, principalmente los conceptos
fundacionales, en los primeros intentos de sustentar métodos analíticos e
implementación en algoritmos de cómputo que permitieron establecer los primeros
pasos en el campo del procesamiento digital de imágenes. Se incorporan
continuamente nuevas técnicas, muchas de las cuales basan en el uso de nuevos
conceptos o bien la aplicación de conceptos conocidos a esta área específica. Por
ejemplo, muchas metodologías de teoría de información son volcadas, adaptadas e
implementadas para el desarrollo de métodos de procesamiento digital de imágenes,
incluso conceptos propios de la matemática y física, como por ejemplo medidas o
métricas y entropía.
 II. MARCO TEORICO

Se podría decir que en la actualidad cualquier equipo electrónico que podamos

encontrar a nuestro alrededor funciona con uno o varios procesadores digitales, las
cuales una imagen puede considerarse como un objeto cuya intensidad luminosa y
color puede variar de un punto a otro, y si se trata de imágenes monocromas se puede
representar como una fundación continua. Por ello Martínez sostiene que:

Lo que vendría hacer una imagen digital es una imagen que fue
discretizada en sus coordenadas especiales, como también su
intensidad luminosa, cada elemento como las   pequeñas unidades que
compone un gráfico digital de una imagen recibe el nombre píxel (2010.p.68)

De esta manera concluyó La imagen digital es, por su naturaleza, económica, ya que es
de fácil duplicación, y puede ser de acceso simultáneo. No gasta materiales en su
producción y no hay que crear nuevos recursos de hardware que los que generalmente
existen

John F. Canny fue el fundador de la teoría computacional de la detección de bordes, la

cual es un operador o filtro encargado de encontrar las regiones de una imagen digital
en las cuales esta cambia su brillo drásticamente donde los puntos más importantes
que debe tener un detector de bordes para ser correcto son: Detección con bajos
niveles de errores. Es decir, el algoritmo debe detectar con precisión tantos bordes en
la imagen Por ello. Chacón nos menciona:

El método de canny define que el éxito de algoritmo detección de borde se basa

en la definición de un conjunto adecuado de metas para definir los puntos de
borde, las condiciones que define canny son dos posteriormente la extiende a
una tercera, las primeras dos son: el error de detección de bordes, que indica que
se deben de localizar todos los bordes y no se deben generar respuestas falsas.
La segunda se refiere a la localización del borde como borde real. La tercera
meta se agrega ya que las dos primeras no son suficientes y es para evitar la
posibilidad de tener respuestas múltiples. (2016, p, 184)
Por lo mencionado anteriormente, el algoritmo de Canny es uno de los mejores
métodos para la detección de bordes, el cual aplica métodos de diferencias finitas
basado en la primera derivada y cuya popularidad se debe, además de sus buenos
resultados, a su sencillez, la cual que permite una gran velocidad de procesamiento al
ser implementado. utiliza el cálculo de variaciones, una técnica que encuentra la
función que optimiza un funcional indicado. La función óptima en el algoritmo de
Canny es descrito por la suma de cuatro términos exponenciales, pero se puede
aproximar por la primera derivada de una gaussiana
Los detectores de bordes lo primero que haces es aplicar un operador derivado a una
imagen suavizada, y establece mayor intensidad de pixeles que no se encuentran en
dicho objeto.

Según Martin mención que un borde puede definirse como un cambio significativo en
el valor de la intensidad de los pixeles en una región de la imagen (2017, p. 48).

Por lo expuesto se puede mencionar que en la era de la tecnología y constante

crecimiento de la misma, los humanos utilizamos estas técnicas que nos permite aislar
los objetos y separarlos del fondo, al haber obtenido los bordes, lo único que nos
faltaría es detectar los diferentes contornos, con estas técnicas nosotros podemos
facilitar más este tipo de actividades en nuestra vida cotidiana.

En la actualidad utilizamos técnicas para la mejorar las fotos antiguas, además es una
tecnología que extrae la información estructural de diferentes objetos, y estos
algoritmos de detección de bordes deben de cumplir con los estándares. Por ello Ehu
nos menciona.
Según Ehu nos dice el operador de Canny basa su operación en los siguientes
criterios:
1. Buena detección: El detector debe distinguir con suficiente Margen entre
bordes verdaderos y bordes falsos. Esto implica, por un lado, marcar con alta
probabilidad puntos tipo bordes reales. Por otro lado, el detector debe marcar,
con baja probabilidad, puntos que no son bordes. Este criterio corresponde a
maximizar la relación señal/ruido.
2. Buena localización: Los puntos marcados como bordes deben corresponder
en lo posible con los centros de los bordes verdaderos.
3. Respuesta única: En lo posible, el detector debe responder con un solo
borde. Esto, de alguna manera, queda implícito en el primer criterio, ya que
cuando existen dos respuestas para un mismo borde una de ellas se debe
considerar como falsa. Sin embargo, la forma matemática del primer criterio no
toma en cuenta el requisito de múltiples respuestas y por tanto esto se debe
especificar de manera explícita (2017, p.50).
Según lo mencionado por Ehu se deduce que el algoritmo del detector de borde de
Canny regularmente toma una imagen en escala de grises como ingreso y causa una
imagen que muestra el lugar de las discontinuidades de intensidad de los bordes,
además este algoritmo tiene el propósito de comprimir elocuentemente el tamaño de
los datos de la imagen mientras se conservan los atributos de la imagen original. El
algoritmo detector de bordes nos muestra lo que pasa al interior de estas imágenes en
desde un punto de vista de alto nivel.

Los bordes definen procesamientos de imágenes digitales, que se produce un fuerte

cambio de intensidad. la detección de bordes requiere muchas veces en variar tareas
de procesamiento de imágenes y visión por ordenador, para segmentación de
imágenes. Estas tareas son aplicadas a áreas tales como teledetección, la medicina,
etc. los pasos de detección de bordes ayudan al análisis de las imágenes radicalmente
la cantidad de datos, al mismo tiempo permite preservar la información estructural útil.
Ciertamente existe una gran diversidad de aplicaciones para la detección de bordes
que muchas de estas aplicaciones comparten un conjunto entre ellos tener la baja tasa
de error en el proceso de detección.

En las últimas década, se han propuesto distintas técnicas de bordes de imágenes

como ejemplo la (Mac, Yang , etc ) Estas técnicas se propone a la detección de bordes
usando una aproximación de máscaras circulares y también asociando cada punto de
la imagen con un área local. Se podría decir que el inconveniente que hay en esta
técnica es la alta sensibilidad al ruido y la poca capacidad para discriminar sus bordes.
Por otro lado, la forma de que se pueda eliminar el ruido vendría hacer utilizando el
filtro Gaussiano que se utiliza manualmente.

III. DESARROLLO

- Pasos de algoritmo de Canny

1. Proceso en escala de grises

Algoritmo de detección de bordes se encarga de procesar imágenes RGB en escala
de grises.
2. Filtro suave gaussiano
El filtro gaussiano se utiliza para el proceso de algoritmo de detección de bordes a
datos, por ello se usa este filtro donde la imagen resultante es la imagen original
donde está ligeramente borrosa en comparación con la imagen original. Hace que el
ruido de un solo píxel casi no tenga efecto en la imagen suavizada gaussiana.
Si una ventana de 3 * 3 en la imagen es A, y el píxel a filtrar es e, después del filtrado
gaussiano, el valor de brillo del píxel e es:

3. Cálculo de la fuerza y de la dirección del gradiente

En algoritmo canny siempre usara 4 operadores para poder descubrir bordes
horizontales como tambien verticales y los diagonales que se encuentren en la
imagen, similares estos operadores de deteccion de bordes de Roberts, Prewitt, etc.
Se regresará las iniciales de los valores derivados como direccion horizontal Gx yGy
vertical y apartir de ellos se podra determinar el gradiente G del pixel y la direccion
theta
G=G2x+G2y−−−−−−−√ G = G x 2 + G y 2

θ=arctanGyGx θ = arctan ⁡ G y G x
La intensidad del gradiente   θ  siempre sera la G y que la gradiente indicara la
dirección del gradiante Arctan conocida como la función del arco tangente
Los operadores Sobel en direcciones x e y son las siguientes:

El Sx se puede representar si o si con sobel ya que su dirección e sx y se usara para

detectar el borde en la dirección y; el que representa al operador sobel es Sy y es más
utilizado para detectar el borde en la dirección x
Las ventanas de 3x3 serán A y el otro pixel tendrá que calcular el gradiente e, luego
de la convolución con el operador Sobel, el gradiente del píxel e en las direcciones x e
y
4. Supresión no máxima
_Comparación de la intensidad con dos pixeles y el pixel actual a lo largo de las direcciones
gradiente y negativa
_Un pixel si o si permanece como un borde si es que la intensidad del pixel gradiente es mas
grande en comparación de los otros pixeles
_Si obtenemos el gradiente de pixeles es debido a que se usa la interpolacion lineal entre dos
pixeles adyacentes en la direccion del gradiente

En la figura mostrada podemos ver que el gradiente si o si se está dividiendo en 8

direcciones entonces se podría decir, a saber, E, NE, N, NW, W, SW, S, SE,
La cual o representa o ° ~ 45 °, 1 representa 45 ° ~ 90 °, 2 representa -90 ° ~ -45 ° y 3
representa -45 ° ~ 0 °. Y e gradiante pixel P es θ

5.Detección de umbral doble

El pixel del borde mayor es umbral alto, a esto se lo denomina como un pixel del borde fuert, el valor
que tiene el pixel del borde es mas alto que el umbral bajo y mas bajo que el umbral alto entonces se
marca como un pixen del borde fragil y si el si el valor del gradiante del pixel del borde es
inferior al umbral bajo, el pixel se suprime

6.Suprimir aislados de umbral bajo

Los pixeles que viene entre los 8 pixeles con los conectados del borde se conservan como el borde
verdadero, el real; caso contrario seria suprima pixel

IV. ALGORITMO CANY

V. import cv2
import numpy as np
import matplotlib.pyplot as plt
import math

def sHalf(T, sigma):

temp = -np.log(T) * 2 * (sigma ** 2)
return np.round(np.sqrt(temp))

def calculate_filter_size(T, sigma):

return 2*sHalf(T, sigma) + 1

def MaskGeneration(T, sigma):

N = calculate_filter_size(T, sigma)
shalf = sHalf(T, sigma)
y, x = np.meshgrid(range(-int(shalf), int(shalf) + 1),
range(-int(shalf), int(shalf) + 1))
return x, y
def Gaussian(x,y, sigma):
temp = ((x ** 2) + (y ** 2)) / (2 * (sigma ** 2))
return (np.exp(-temp))

def calculate_gradient_X(x,y, sigma):

temp = (x ** 2 + y ** 2) / (2 * sigma ** 2)
return -((x * np.exp(-temp)) / sigma ** 2)

def calculate_gradient_Y(x,y, sigma):

temp = (x ** 2 + y ** 2) / (2 * sigma ** 2)
return -((y * np.exp(-temp)) / sigma ** 2)

def pad(img, kernel):

r, c = img.shape
kr, kc = kernel.shape
padded = np.zeros((r + kr, c + kc), dtype=img.dtype)
insert = np.uint((kr) / 2)
padded[insert: insert + r, insert: insert + c] = img
return padded

def smooth(img, kernel=None):

if kernel is None:
mask = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
else:
mask = kernel
i, j = mask.shape
output = np.zeros((img.shape[0], img.shape[1]))
image_padded = pad(img, mask)
for x in range(img.shape[0]):
for y in range(img.shape[1]):
output[x, y] = (mask * image_padded[x:x + i, y:y +
j]).sum() / mask.sum()
return output

def Create_Gx(fx, fy):

gx = calculate_gradient_X(fx, fy, sigma)
gx = (gx * 255)
return np.around(gx)

def Create_Gy(fx, fy):

gy = calculate_gradient_Y(fx, fy, sigma)
gy = (gy * 255)
return np.around(gy)

def ApplyMask(image, kernel):

i, j = kernel.shape
kernel = np.flipud(np.fliplr(kernel))
output = np.zeros_like(image)
image_padded = pad(image, kernel)
for x in range(image.shape[0]):
for y in range(image.shape[1]):
output[x, y] = (kernel * image_padded[x:x+i,
y:y+j]).sum()
return output

def Gradient_Magnitude(fx, fy):

mag = np.zeros((fx.shape[0], fx.shape[1]))
mag = np.sqrt((fx ** 2) + (fy ** 2))
mag = mag * 100 / mag.max()
return np.around(mag)
def Gradient_Direction(fx, fy):
g_dir = np.zeros((fx.shape[0], fx.shape[1]))
g_dir = np.rad2deg(np.arctan2(fy, fx)) + 180
return g_dir

def Gradient_Magnitude(fx, fy):

mag = np.zeros((fx.shape[0], fx.shape[1]))
mag = np.sqrt((fx ** 2) + (fy ** 2))
mag = mag * 100 / mag.max()
return np.around(mag)

def Gradient_Direction(fx, fy):

g_dir = np.zeros((fx.shape[0], fx.shape[1]))
g_dir = np.rad2deg(np.arctan2(fy, fx)) + 180
return g_dir

def Digitize_angle(Angle):
quantized = np.zeros((Angle.shape[0], Angle.shape[1]))
for i in range(Angle.shape[0]):
for j in range(Angle.shape[1]):
if 0 <= Angle[i, j] <= 22.5 or 157.5 <= Angle[i, j]
<= 202.5 or 337.5 < Angle[i, j] < 360:
quantized[i, j] = 0
elif 22.5 <= Angle[i, j] <= 67.5 or 202.5 <= Angle[i,
j] <= 247.5:
quantized[i, j] = 1
elif 67.5 <= Angle[i, j] <= 122.5 or 247.5 <=
Angle[i, j] <= 292.5:
quantized[i, j] = 2
elif 112.5 <= Angle[i, j] <= 157.5 or 292.5 <=
Angle[i, j] <= 337.5:
quantized[i, j] = 3
return quantized

def Non_Max_Supp(qn, magni, D):

M = np.zeros(qn.shape)
a, b = np.shape(qn)
for i in range(a - 1):
for j in range(b - 1):
if qn[i, j] == 0:
if magni[i, j - 1] < magni[i, j] or magni[i, j] >
magni[i, j + 1]:
M[i, j] = D[i, j]
else:
M[i, j] = 0
if qn[i, j] == 1:
if magni[i - 1, j + 1] <= magni[i, j] or magni[i,
j] >= magni[i + 1, j - 1]:
M[i, j] = D[i, j]
else:
M[i, j] = 0
if qn[i, j] == 2:
if magni[i - 1, j] <= magni[i, j] or magni[i, j]
>= magni[i + 1, j]:
M[i, j] = D[i, j]
else:
M[i, j] = 0
if qn[i, j] == 3:
if magni[i - 1, j - 1] <= magni[i, j] or magni[i,
j] >= magni[i + 1, j + 1]:
M[i, j] = D[i, j]
else:
M[i, j] = 0
 return M

def color(quant, mag):

color = np.zeros((mag.shape[0], mag.shape[1], 3), np.uint8)
a, b = np.shape(mag)
for i in range(a - 1):
for j in range(b - 1):
if quant[i, j] == 0:
if mag[i, j] != 0:
color[i, j, 0] = 255
else:
color[i, j, 0] = 0
if quant[i, j] == 1:
if mag[i, j] != 0:
color[i, j, 1] = 255
else:
color[i, j, 1] = 0
if quant[i, j] == 2:
if mag[i, j] != 0:
color[i, j, 2] = 255
else:
color[i, j, 2] = 0
if quant[i, j] == 3:
if mag[i, j] != 0:
color[i, j, 0] = 255
color[i, j, 1] = 255

else:
color[i, j, 0] = 0
color[i, j, 1] = 0
return color

def _double_thresholding(g_suppressed, low_threshold,

high_threshold):
g_thresholded = np.zeros(g_suppressed.shape)
for i in range(0, g_suppressed.shape[0]): # loop over
pixels
for j in range(0, g_suppressed.shape[1]):
if g_suppressed[i,j] < low_threshold: # lower than
low threshold
g_thresholded[i,j] = 0
elif g_suppressed[i,j] >= low_threshold and
g_suppressed[i,j] < high_threshold: # between thresholds
g_thresholded[i,j] = 128
else: # higher than high
threshold
g_thresholded[i,j] = 255
return g_thresholded

def _hysteresis(g_thresholded):
g_strong = np.zeros(g_thresholded.shape)
for i in range(0, g_thresholded.shape[0]): # loop over
pixels
for j in range(0, g_thresholded.shape[1]):
val = g_thresholded[i,j]
if val == 128: # check if weak edge connected
to strong
if g_thresholded[i-1,j] == 255 or
g_thresholded[i+1,j] == 255 or g_thresholded[i-1,j-1] == 255 or
g_thresholded[i+1,j-1] == 255 or g_thresholded[i-1,j+1] == 255 or
g_thresholded[i+1,j+1] == 255 or g_thresholded[i,j-1] == 255 or
g_thresholded[i,j+1] == 255:
g_strong[i,j] = 255 # replace weak edge
as strong
 elif val == 255:
g_strong[i,j] = 255 # strong edge remains
as strong edge
return g_strong

sigma = 0.5
T = 0.3
x, y = MaskGeneration(T, sigma)
gauss = Gaussian(x, y, sigma)

gx = -Create_Gx(x, y)
gy = -Create_Gy(x, y)

image = cv2.imread('barras1.png')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
plt.figure(figsize = (8,8))
plt.imshow(gray, cmap='gray')
plt.title('ESCALA GRISES')

smooth_img = smooth(gray, gauss)

plt.figure(figsize = (8,8))
plt.imshow(smooth_img, cmap='gray')
plt.title('SUAVIZADO')

fx = ApplyMask(smooth_img, gx)
plt.figure(figsize = (8,8))
plt.imshow(fx, cmap='gray')
plt.title('DEGRADADO X')

fy = ApplyMask(smooth_img, gy)
plt.figure(figsize = (8,8))
plt.imshow(fy, cmap='gray')
plt.title('DEGRADADO Y')

mag = Gradient_Magnitude(fx, fy)

mag = mag.astype(int)
plt.figure(figsize = (8,8))
plt.imshow(mag, cmap='gray')
plt.title('MAGNITUD DEL GRADIENTE')
print('max', mag.max())
print('min', mag.min())

Angle = Gradient_Direction(fx, fy)

plt.figure(figsize = (5,5))
plt.imshow(Angle, cmap='gray')
plt.title('DEGRADADO X y Y')
print('max', Angle.max())
print('min', Angle.min())

quantized = Digitize_angle(Angle)
nms = Non_Max_Supp(quantized, Angle, mag)
plt.figure(figsize = (10,10))
plt.imshow(nms, cmap='gray')
plt.title('SUPRESION NO MAXIMA')
print('max', nms.max())
print('min', nms.min())

colorized = color(quantized, mag)

plt.figure(figsize = (7,7))
plt.imshow(colorized)
plt.title('COLORIZACION')
cv2.imwrite('color.jpg',colorized)

threshold = _double_thresholding(nms,10,20)
cv2.imwrite('double_thresholded.jpg', threshold )
plt.figure(figsize = (10,10))
plt.imshow(threshold, cmap='gray')
plt.title('DOBLE UMBRAL')

hys = _hysteresis(threshold)
cv2.imwrite('Result.jpg', hys)
plt.figure(figsize = (10,10))
plt.imshow(hys, cmap='gray')
plt.title('HYSTERESIS')
plt.show()
 VI. CONCLUSIONES

En conclusión, el algoritmo de Canny es uno de los mejores métodos para la detección

de bordes.

Mejoro las diferentes formas de observar y cambiar las imágenes.

Marco una diferencia entre el hoy y antes ya que antes no se podía modificar las
imágenes a ese nivel

En este trabajo se ha presentado en el que se detalla todos los pasos necesarios para
conocer los bordes de una imagen mediante el algoritmo de Canny,

Este algoritmo es simple de implementar y eficiente.

Como se observa en los ejemplos los resultados en la aplicación son los previstos, y
de esta manera se observa los necesario e indispensable de este algoritmo

Este informe se detalla los pasos necesarios para conocer los bordes de una imagen
mediante el algoritmo de Canny, este algoritmo de detección de bordes de imágenes
basado en el operador Canny ha sido presentado al usuario mediante una interfaz
gráfica muy intuitiva y de sencillo manejo.

VII. REFERENCIAS BIBLIOGRAFICAS

CHACON, Mario. Percepción visual aplicada a la robótica. Ciudad de México: 2016. 364 pp.
ISBN: 978-607-622-192-1
https://books.google.com.pe/books?id=pCHaDAAAQBAJ&pg=SA1-
PA73&dq=Algoritmo+Canny&hl=es&sa=X&ved=2ahUKEwjArKLTranwAhU0FFkFHYGmA
cQQ6AEwBXoECAIQAg#v=onepage&q=Algoritmo%20Canny&f=false

MARTINEZ, Nistal. Técnicas de fluorescencia en microscopia y citometría.México: 2014

. 32 pp.
ISBN: 84-7468-850-7
https://books.google.com.pe/books?
id=tcCeoc0ubbEC&pg=PA32&dq=procesamiento+digital+de+imagenes&hl=es-
419&sa=X&ved=2ahUKEwiOrNW-
g77wAhUklJUCHfOCDcU4ChDoATABegQIAxAC#v=onepage&q=procesamiento
%20digital%20de%20imagenes&f=false

GONZALES, Jonathan. Reconocimiento de objetos utilizando OpenCV y Python en una Raspberry pi

2 en una tlapalería, México. 2017. 120 pp. disponible en:
http://ri.uaemex.mx/bitstream/handle/20.500.11799/68150/tesis%20opencv%20python.pdf?
sequence=1&isAllowed=y