Código de Python - Red-CNN Detección de bordes

Imágen de perfil

Red-CNN Detección de bordesgráfica de visualizaciones


Python

Publicado el 19 de Febrero del 2024 por Hilario (126 códigos)
254 visualizaciones desde el 19 de Febrero del 2024
Figure_1
Figure_2

Los kernels Sobel son filtros utilizados comúnmente en procesamiento de imágenes para realizar operaciones de convolución, especialmente en el contexto de detección de bordes. Estos filtros están diseñados para resaltar cambios rápidos en la intensidad de los píxeles en una imagen, lo que generalmente indica la presencia de bordes.

El operador Sobel consiste en dos kernels, uno para la detección de cambios horizontales y otro para cambios verticales. Estos kernels son matrices pequeñas que se aplican a la imagen mediante la operación de convolución. Los kernels Sobel comúnmente utilizados son los siguientes:

Kernel Sobel para detección de bordes horizontales (kernel_sobel_x):

[ -1, 0, 1]
[ -2, 0, 2]
[ -1, 0, 1]

Kernel Sobel para detección de bordes verticales (kernel_sobel_y):

[ 1, 2, 1]
[ 0, 0, 0]
[-1, -2, -1]

La operación de convolución implica deslizar estos kernels sobre la imagen original, multiplicando los valores de los píxeles en la región correspondiente del kernel y sumándolos para obtener un nuevo valor en la posición central. Este proceso se repite para cada píxel en la imagen, generando así dos nuevas imágenes filtradas: una resaltando cambios horizontales y otra resaltando cambios verticales.

La magnitud de los bordes se calcula combinando las respuestas horizontales y verticales mediante una fórmula de magnitud Euclidiana.

Este resultado proporciona una representación de la intensidad de los bordes en la imagen original, lo cual es útil para tareas como detección de contornos. En el código que compartiste anteriormente, estos kernels Sobel se utilizan para realizar la detección de bordes en la imagen cargada.


Este programa en Python: python3 Aula_28_bordes_CNN.py, realiza la detección de bordes en una imagen utilizando el operador Sobel. Aquí tienes una explicación paso a paso:

Cargar la imagen:
Utiliza la biblioteca OpenCV (cv2) para cargar una imagen desde la ruta "/home/margarito/python/tulipanes.jpeg".
Verifica si la carga de la imagen fue exitosa.

Convertir la imagen a formato RGB:
Utiliza la función cv2.cvtColor para convertir la imagen cargada (en formato BGR) a formato RGB.
Muestra la imagen original utilizando la biblioteca matplotlib.

Definir los kernels Sobel:
Define dos kernels Sobel, uno para la detección de bordes horizontales (kernel_sobel_x) y otro para la detección de bordes verticales (kernel_sobel_y).

Aplicar los filtros Sobel:
Utiliza la función cv2.filter2D para aplicar los filtros Sobel a la imagen original, obteniendo dos imágenes resultantes (imagen_bordes_x e imagen_bordes_y), que representan los bordes horizontales y verticales, respectivamente.

Calcular la magnitud de los bordes:
Calcula la magnitud de los bordes combinando las imágenes resultantes de los filtros Sobel mediante la fórmula de la magnitud Euclidiana.

Verificar si hay datos válidos en la matriz antes de normalizar:
Antes de normalizar la magnitud de los bordes, verifica si hay datos válidos en la matriz utilizando np.any.

Convertir a tipo de datos float32 antes de normalizar:
Convierte la matriz de magnitud de bordes a tipo de datos float32. Esto es necesario para evitar problemas de normalización con tipos de datos no compatibles.

Normalizar la imagen:
Utiliza el método de normalización para escalar los valores de la magnitud de los bordes al rango [0, 1]. Esto es importante para visualizar correctamente la imagen de bordes.

Mostrar la imagen con bordes:
Utiliza plt.imshow para mostrar la imagen resultante de la detección de bordes en escala de grises.
Muestra un título indicando que se ha aplicado el operador Sobel para la detección de bordes.

Manejar casos donde la matriz de magnitud de bordes está vacía:
Si la matriz de magnitud de bordes está vacía (todos los elementos son cero), imprime un mensaje indicando que la matriz está vacía o no contiene datos válidos.

En resumen, este programa carga una imagen, aplica el operador Sobel para detectar bordes y muestra la imagen resultante de la detección de bordes. Además, maneja casos donde la matriz de magnitud de bordes no contiene datos válidos.

Requerimientos

Programa realizado bajo linux, con la plataforma: Ubuntu 20.04.6 LTS.
Editado con Sublime Text.

El sistema debe de tener cargados para poder importarlos,
los siguientes Módulos:
import cv2
import numpy as np
import matplotlib.pyplot as plt

Cargado python3

****************************************************************************************
Ejecución bajo consola Linux.:
python3 Aula_28_bordes_CNN.py

V-0.

Publicado el 19 de Febrero del 2024gráfica de visualizaciones de la versión: V-0.
255 visualizaciones desde el 19 de Febrero del 2024
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# Ejecucuión: python3 Aula_28_bordes_CNN.py
 
import cv2
import numpy as np
import matplotlib.pyplot as plt
 
# Cargar la imagen y verificar la carga
imagen_original = cv2.imread("/home/margarito/python/tulipanes.jpeg")
 
if imagen_original is None:
    print("No se pudo cargar la imagen.")
else:
    # Convertir la imagen a formato RGB
    imagen_original = cv2.cvtColor(imagen_original, cv2.COLOR_BGR2RGB)
 
    # Mostrar la imagen original
    plt.imshow(imagen_original)
    plt.title("Imagen Original")
    plt.show()
 
    # Definir los kernels Sobel para detección de bordes
    kernel_sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
    kernel_sobel_y = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
 
    # Aplicar los filtros Sobel
    imagen_bordes_x = cv2.filter2D(imagen_original, -1, kernel_sobel_x)
    imagen_bordes_y = cv2.filter2D(imagen_original, -1, kernel_sobel_y)
 
    # Calcular la magnitud de los bordes
imagen_bordes_magnitud = np.sqrt(imagen_bordes_x**2 + imagen_bordes_y**2)
 
# Verificar si hay datos válidos en la matriz antes de normalizar
if np.any(imagen_bordes_magnitud):
    # Convertir a tipo de datos float32 antes de normalizar
    imagen_bordes_magnitud = imagen_bordes_magnitud.astype(np.float32)
 
    # Normalizar la imagen para visualizarla correctamente
    imagen_bordes_magnitud = (imagen_bordes_magnitud - np.min(imagen_bordes_magnitud)) / (np.max(imagen_bordes_magnitud) - np.min(imagen_bordes_magnitud))
 
    # Mostrar la imagen con bordes
    plt.imshow(imagen_bordes_magnitud, cmap="gray")
    plt.title("Detección de Bordes con Operador Sobel")
    plt.show()
else:
    print("La matriz de magnitud de bordes está vacía o no contiene datos válidos.")



Comentarios sobre la versión: V-0. (0)


No hay comentarios
 

Comentar la versión: V-0.

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s7494