OpenCV (Open source Computer Vision Library) é unha biblioteca de software de código aberto que contén máis de 2,500 algoritmos optimizados para o procesamento de imaxes e visión por computadora. Estes algoritmos permiten facer cousas como detectar rostros, identificar obxectos, clasificar accións humanas en vídeos, rastrexar o movemento de obxectos, e moito máis.
◦ Obxectivo: Aprender a subir, mostrar e modificar unha imaxe con OpenCV.
◦ Instrución: Sube un arquivo de imaxe a Colab e móstraa.
import cv2 Importación da biblioteca
imaxe = cv2.imread(list(uploaded.keys())[0]) Este método carga unha imaxe desde unha ruta de arquivo específica. No programa, a función list(uploaded.keys())[0] obtén o nome da imaxe subida. A imaxe é cargada como unha matriz (array) en Python, onde cada elemento representa un píxel coa súa cor (RGB).
cv2_imshow(imaxe) Esta é unha función específica de Google Colab (non forma parte de OpenCV). Permite mostrar unha imaxe directamente no entorno de Google Colab, xa que as funcións normais de visualización como cv2.imshow non son compatibles con Colab.
Converter a imaxe a escala de grises:
Engade o seguinte código dentro do mesmo caderno para transformar a imaxe e visualizala en escala de grises:
# Converter a imaxe a escala de grises
imaxe_gris = cv2.cvtColor(imaxe, cv2.COLOR_BGR2GRAY)
# Mostrar a imaxe en escala de grises
cv2_imshow(imaxe_gris)
Redimensionar a imaxe:
Proba a modificar o tamaño da imaxe engadindo isto nunha nova celda do caderno:
# Redimensionar a imaxe a 50% do seu tamaño orixinal
ancho = int(imaxe.shape[1] * 0.5)
alto = int(imaxe.shape[0] * 0.5)
dimension = (ancho, alto)
imaxe_redimensionada = cv2.resize(imaxe, dimension)
# Mostrar a imaxe redimensionada
cv2_imshow(imaxe_redimensionada)
Gardar a imaxe transformada:
Engade este código para gardar unha imaxe modificada(por exemplo a gris) no teu sistema:
# Gardar a imaxe en escala de grises como "imaxe_gris.jpg"
cv2.imwrite("imaxe_gris.jpg", imaxe_gris)
print("A imaxe en escala de grises foi gardada como 'imaxe_gris.jpg'.")
# Importar o módulo de carga de arquivos desde Google Colab
from google.colab import files
# Subir arquivos desde o ordenador do usuario
# Isto abrirá un diálogo para seleccionar a imaxe que desexes cargar
uploaded = files.upload() # Subida do arquivo de imaxe
# Importar a biblioteca OpenCV e unha función específica de Google Colab para mostrar imaxes
import cv2
from google.colab.patches import cv2_imshow
# Ler a imaxe (asumindo que só subiches unha imaxe)
# A clave do dicionario 'uploaded.keys()' é o nome do arquivo cargado
imaxe = cv2.imread(list(uploaded.keys())[0])
# Verificar se a imaxe se cargou correctamente
if imaxe is None:
# Mensaxe de erro en caso de que a imaxe non se cargase correctamente
print("Erro: Non se puido cargar a imaxe. Verifica a ruta do arquivo.")
else:
# Mostrar a imaxe cargada
cv2_imshow(imaxe)
# Verificar se a imaxe se cargou correctamente
◦ Obxectivo: Aprender a realizar transformacións de cor nunha imaxe e a importancia para a IA.
◦ Instrución: Aplicar a unha imaxe as transformacións: escala de grises, espacio de color HSV, espacio de color RGB (BGR a RGB), espacio de color YUV, espacio de color LAB.
Imaxina que estás a ver unha película en branco e negro, e de súpeto convértese nunha película a todo cor. Iso sería emocionante! No mundo da IA, facer cousas como esta é moi útil e ten moitos propósitos.
Exemplo 1: Atopar Bordos
Cando transformamos unha imaxe en branco e negro (ou en escala de grises), é máis fácil para a computadora atopar os bordos dos obxectos. Pensa nun debuxo dun libro de colorear. Os bordos en negro axudan a saber onde están as figuras. Desta maneira, a computadora pode identificar obxectos como caras, coches ou edificios.
Exemplo 2: Mellorar a Visión Nocturna
Ás veces, necesitamos ver cousas en condicións de pouca luz, como na noite. A computadora pode transformar a imaxe para facela máis clara. É coma se usases unhas lentes especiais que che permiten ver na escuridade.
Exemplo 3: Detectar Obxectos
Cando a computadora converte unha imaxe en diferentes cores, pode identificar e separar diferentes obxectos máis facilmente. Por exemplo, se tes unha foto dunha mesa con froitas, a computadora pode identificar as mazás, as laranxas e os plátanos polas súas cores.
Exemplo 4: Crear Efectos Especiais
Transformar imaxes tamén pode ser divertido. Podes usar filtros para facer que as fotos parezan antigas, desenfocadas ou mesmo convertelas en debuxos animados. É como usar unha aplicación de edición de fotos no teu teléfono.
Por Que é Importante?
Transformar imaxes axuda ás computadoras para "ver" e entender o mundo como o facemos nós.
Poden identificar persoas, ler sinais de tráfico, e ata axudar aos médicos para detectar enfermidades en radiografías e resonancias.
En resumo, transformar imaxes en IA é como darlle ás computadoras unha visión máis clara e precisa do mundo para que poidan axudarnos en moitas tarefas cotiás e facer cousas incribles.
cv2.imread Carga a imaxe desde unha ruta ou ficheiro específico e almacénao como unha matriz numpy.
cv2.resize Redimensiona a imaxe a unha dimensión especificada (ancho e alto).
interpolation=cv2.INTER_AREA Axuda a manter a calidade da imaxe cando se redimensiona a tamaños máis pequenos.
cv2.cvtColor Converte a imaxe ao espazo de cor especificado. Exemplos no código:
cv2.COLOR_BGR2GRAY: Converte a escala de grises.
cv2.COLOR_BGR2HSV: Converte ao espazo de cor HSV.
cv2.COLOR_BGR2RGB: Converte ao espazo RGB.
cv2.COLOR_BGR2YUV: Converte ao espazo YUV.
cv2.COLOR_BGR2LAB: Converte ao espazo LAB.
cv2.putText Engade un texto sobre a imaxe. O texto inclúe a posición, tamaño da fonte, cor, grosor e un estilo de liña.
np.hstack Combina varias imaxes nunha soa matriz horizontal para mostralas xuntas.
cv2_imshow É unha función de Google Colab que permite mostrar imaxes no entorno Colab (similar a cv2.imshow en aplicacións locais).
Aplicar bordos á imaxe:
Engade bordos usando o método cv2.copyMakeBorder:
imaxe_bordo = cv2.copyMakeBorder(imaxe_redimensionada, 10, 10, 10, 10, cv2.BORDER_CONSTANT, value=(0, 0, 0))
Converter a imaxe a negativo:
Usa o seguinte código:
negativo = cv2.bitwise_not(imaxe_redimensionada)
cv2_imshow(negativo)
Engadir máis espazos de cor:
Proba outros espazos como cv2.COLOR_BGR2XYZ e cv2.COLOR_BGR2HLS
# Importar o módulo de carga de arquivos desde Google Colab
from google.colab import files
# Subir arquivos desde o ordenador do usuario
# Isto abrirá un diálogo para seleccionar a imaxe que desexes cargar
uploaded = files.upload() # Subida do arquivo de imaxe
# Importar a biblioteca OpenCV, cv_2imshow e unha función específica de Google Colab para mostrar imaxes
import cv2
import numpy as np #Para mostrar as imaxes concatenadas na mesma fila
from google.colab.patches import cv2_imshow
# Ler a imaxe (asumindo que só subiches unha imaxe)
imaxe = cv2.imread(list(uploaded.keys())[0]) # Cargar o arquivo seleccionado
# Verificar se a imaxe se cargou correctamente
if imaxe is None:
print("Erro: Non se puido cargar a imaxe. Verifica a ruta do arquivo.")
else:
# Redimensionar a imaxe
ancho_novo = 300 # Especificar o novo ancho
alto_novo = 300 # Especificar o novo alto
dimension = (ancho_novo, alto_novo)
imaxe_redimensionada = cv2.resize(imaxe, dimension, interpolation=cv2.INTER_AREA)
# Función para engadir texto á imaxe
def engadir_texto(img, texto):
return cv2.putText(img, texto, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)
# Converter a imaxe a escala de grises e engadir texto
gris = cv2.cvtColor(imaxe_redimensionada, cv2.COLOR_BGR2GRAY)
gris_cor = cv2.cvtColor(gris, cv2.COLOR_GRAY2BGR) # Converter a BGR para engadir texto
gris_texto = engadir_texto(gris_cor, 'Escala de Grises')
# Converter a imaxe ao espazo de cor HSV e engadir texto
hsv = cv2.cvtColor(imaxe_redimensionada, cv2.COLOR_BGR2HSV)
hsv_texto = engadir_texto(hsv, 'HSV')
# Converter a imaxe ao espazo de cor RGB e engadir texto
rgb = cv2.cvtColor(imaxe_redimensionada, cv2.COLOR_BGR2RGB)
rgb_texto = engadir_texto(rgb, 'RGB')
# Converter a imaxe ao espazo de cor YUV e engadir texto
yuv = cv2.cvtColor(imaxe_redimensionada, cv2.COLOR_BGR2YUV)
yuv_texto = engadir_texto(yuv, 'YUV')
# Converter a imaxe ao espazo de cor LAB e engadir texto
lab = cv2.cvtColor(imaxe_redimensionada, cv2.COLOR_BGR2LAB)
lab_texto = engadir_texto(lab, 'LAB')
# Concatenar todas as imaxes horizontalmente
imaxe_concatenada = np.hstack((gris_texto, hsv_texto, rgb_texto, yuv_texto, lab_texto))
# Mostrar as imaxes concatenadas
cv2_imshow(imaxe_concatenada)
cv2.COR_BGR2GRAY: Converte unha imaxe de BGR a escala de grises.
Que fai: Converte unha imaxe de cor nunha imaxe en branco e negro.
Exemplo: Imaxina que tes unha foto en cor do teu can e transfórmala nunha foto en branco e negro. Isto é útil para resaltar as formas e bordos na imaxe.
Aplicación en IA: Detectar bordos ou recoñecer formas nunha imaxe, xa que en escala de grises é máis fácil para a computadora identificar detalles.
Sintaxe: gris = cv2.cvtColor(imaxe, cv2.COR_BGR2GRAY)
cv2.COLOR_BGR2HSV: Converte unha imaxe de BGR a HSV (Hue, Saturation, Value).
Que fai: Converte unha imaxe de cor noutro tipo de imaxe onde se utilizan o ton (H), a saturación (S) e o valor (V) en lugar das cores tradicionais.
Exemplo: Pensa nun filtro de Instagram que cambia a tonalidade e saturación da imaxe para facer que as cores sexan máis vivos.
Aplicación en IA: Detección de cores específicas. Por exemplo, atopar todas as mazás vermellas nunha foto.
Sintaxe: hsv = cv2.cvtColor(imaxe, cv2.COR_BGR2HSV)
cv2.COLOR_BGR2RGB: Converte unha imaxe de BGR a RGB.
Que fai: Cambia a maneira en que se gardan as cores na imaxe, de BGR (azul, verde, vermello) a RGB (vermello, verde, azul).
Exemplo: É como reorganizar as cores nunha caixa de lapis de cores para que estean nunha orde diferente.
Aplicación en IA: Asegurarse de que as cores se mostren correctamente en diferentes programas. A miúdo, as imaxes en OpenCV están en formato BGR, mentres que en moitas outras bibliotecas úsase RGB.
Sintaxe: rgb = cv2.cvtColor(imaxe, cv2.COR_BGR2RGB)
cv2.COLOR_BGR2YUV: Converte unha imaxe de BGR a YUV.
Que fai: Converte a imaxe a un espazo de cor que separa a luminancia (E) e a crominancia (Ou e V).
Exemplo: É como dividir unha imaxe no seu brillo e as súas cores, como axustar o brillo e o contraste nunha foto.
Aplicación en IA: Mellora a calidade de imaxe en transmisións de vídeo e compresión de vídeo.YUV separa a imaxe en compoñentes de luminancia (E) e crominancia (Ou, V), útil para compresión de vídeo e televisión.
Sintaxe: yuv = cv2.cvtColor(imaxe, cv2.COR_BGR2YUV)
cv2.COLOR_BGR2LAB: Converte unha imaxe de BGR a CIELAB.
Que fai: Converte a imaxe nun espazo de cor que é máis próximo a como os humanos percibimos as cores.
Exemplo: É como ter unha representación das cores que é máis precisa e natural á vista humana.
Aplicación en IA: Procesamento de imaxes onde se necesita unha alta precisión nas cores, como na edición fotográfica profesional.
Sintaxe: lab = cv2.cvtColor(imaxe, cv2.COR_BGR2LAB)
cv2.COR_BGR2XYZ: Converte unha imaxe de BGR a espazo de cor XYZ.
Que fai: Converte a imaxe a un espazo de cor definida pola Comisión Internacional de Iluminación (CIE).
Exemplo: É como usar un estándar internacional para asegurarse de que as cores sexan consistentes en diferentes dispositivos.
Aplicación en IA: Asegurarse de que as cores se vexan da mesma maneira en diferentes pantallas e dispositivos.
Sintaxe: xyz = cv2.cvtColor(imaxe, cv2.COR_BGR2XYZ)
cv2.COR_BGR2HLS: Converte unha imaxe de BGR a HLS (Hue, Lightness, Saturation).
Que fai: Converte a imaxe a un espazo de cor usando o ton (H), a luminosidade (L) e a saturación (S).
Exemplo: Similar ao espazo HSV, pero cunha representación diferente da luminosidade.
Aplicación en IA: Manipulación avanzada de imaxes para axustar cores e brillo de maneira precisa.
Sintaxe: hls = cv2.cvtColor(imaxe, cv2.COR_BGR2HLS)
◦ Obxectivo: Comprender como detectar bordos nunha imaxe e a súa importancia en IA.
◦ Instrución: Detectar os bordos nunha imaxe usando o algoritmo Canny .
cv2.Canny(): Aplica o algoritmo de Canny para detectar bordos na imaxe. Os parámetros 100 e 200 son os limiares inferior e superior para o detector de bordos.
cv2.cvtColor(): Converte a imaxe de bordos a BGR para poder agregar texto.
cv2.putText(): Agrega texto á imaxe indicando a transformación realizada.
cv2_imshow(): Mostra a imaxe de bordos en Google Colab.
Este código primeiro carga a imaxe, convértea a escala de grises, aplica o algoritmo de Canny para detectar os bordos e logo mostra a imaxe de bordos co texto agregado.
Proba a axustar os parámetros do algoritmo Canny (100 e 200) para ver como cambian os bordos detectados cambiando limiar inferior e superior. Comproba os cambios na detección de bordos.
Explicación do Algoritmo Canny
Imaxina que estás a debuxar unha figura. Primeiro fas un bosquexo lixeiro para ter unha idea xeral, e logo trazas as liñas dos detalles. O algoritmo de Canny fai o contrario, colle a imaxe e elimina os detalles, quedándose só cos trazos máis relevantes.
Canny é un algoritmo que axuda ás computadoras para atopar os bordos dos obxectos nunha imaxe. Os bordos son como as liñas de contorno no teu debuxo. Isto é útil porque as computadoras necesitan identificar os bordos para recoñecer formas e obxectos. Canny atopa estes bordos detectando cambios bruscos na intensidade da cor da imaxe.
Que fai no programa o filtro Canny?
Imaxina que tes unha foto e queres destacar só as liñas e contornos importantes (como os contornos dos obxectos). O filtro Canny "resalta" eses bordos, axudando ao sistema para entender onde termina un obxecto e onde empeza outro.
Por que é tan útil?
Separar obxectos: Ao identificar os bordos, a IA pode recoñecer formas e separar os elementos (por exemplo, distinguir a unha persoa do fondo).
Preprocesamiento: Moitas veces antes de que un modelo de IA procese unha imaxe, aplícaselle un suavizado (cun filtro Gaussiano) e despois úsanse técnicas como Canny para extraer características esenciais.
Aplicacións prácticas Utilízase en tarefas como a visión por computadora, recoñecemento de obxectos e ata en sistemas de seguridade, xa que axuda a destacar o importante nunha imaxe.
Aínda que moitos modelos modernos aprenden as súas propias ferramentas (filtros) a partir dos datos, comprender e aplicar o filtro Canny dáche unha boa base sobre como se “prepara” unha imaxe para que unha computadora poida analizala e entendela.
O filtro Canny é imprescindible porque ensina como capturar o esencial dunha imaxe: os seus bordos e contornos, o que é fundamental para que os sistemas de IA poidan recoñecer patróns e obxectos.
# Subir a imaxe a Google Colab:
from google.colab import files
uploaded = files.upload() # Isto abrirá un diálogo para seleccionar o arquivo de imaxe no teu ordenador
# Aplicar o algoritmo de Canny e mostrar a imaxe en Google Colab:
import cv2
from google.colab.patches import cv2_imshow
# Ler a imaxe (asumindo que só subiches unha imaxe)
imaxe = cv2.imread(list(uploaded.keys())[0])
# Verificar se a imaxe se cargou correctamente
if imaxe is None:
print("Erro: Non se puido cargar a imaxe. Verifica a ruta do arquivo.")
else:
# Mostrar a imaxe
cv2_imshow(imaxe)
# Converter a imaxe a escala de grises
gris = cv2.cvtColor(imaxe, cv2.COLOR_BGR2GRAY)
# Aplicar o algoritmo de Canny para detectar bordos
bordes = cv2.Canny(gris, 100, 200)
# Converter a imaxe de bordos a BGR para poder engadir texto
bordes_cor = cv2.cvtColor(bordes, cv2.COLOR_GRAY2BGR)
# Engadir texto indicando a transformación realizada
bordes_texto = cv2.putText(bordes_cor, 'Bordos Canny', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2, cv2.LINE_AA)
# Mostrar a imaxe de bordos
cv2_imshow(bordes_texto)
◦ Obxectivo: Aprender a utilizar distintos algoritmos para detección de formas.
◦ Instrución: Detectar círculos nunha imaxe de bicicleta utilizando a Transformada de Hough.
Convértese a imaxe a escala de grises con cv2.cvtColor(), o que facilita moitos procesos de visión.
Suavízase a imaxe con cv2.medianBlur(imaxe_gris, 5) para reducir o ruído e axudar á detección de círculos.
cv2.HoughCircles() analiza a imaxe e detecta círculos baseándose na Transformada de Hough.
Os parámetros usados (como dp, minDist, param1, param2) pódense axustar segundo as características da imaxe para unha detección máis precisa.
Detectar outras formas utilizando contornos. Este código substitúe a detección con HoughCircles pola detección de bordos e contornos, e clasifica a forma segundo o número de vértices.
# Importamos as bibliotecas necesarias:
import cv2 # Para o procesamento de imaxes con OpenCV
import numpy as np # Para o manexo de arrays e operacións matemáticas
from google.colab import files # Para subir arquivos desde o ordenador
from google.colab.patches import cv2_imshow # Función que permite mostrar imaxes en Colab
# 1. Subir a imaxe desde o ordenador:
uploaded = files.upload() # Abrirase un cadro de diálogo para seleccionar a imaxe
# Procesamos cada imaxe subida (xeralmente só se sube unha imaxe)
for filename in uploaded.keys():
print("Arquivo subido:", filename)
# 2. Cargar a imaxe en modo cor (BGR por defecto en OpenCV)
imaxe = cv2.imread(filename)
# 3. Converter a imaxe a escala de grises para facilitar a detección
imaxe_gris = cv2.cvtColor(imaxe, cv2.COLOR_BGR2GRAY)
# 4. Aplicar un filtro de mediana para reducir o ruído e mellorar a detección de bordos
imaxe_gris = cv2.medianBlur(imaxe_gris, 5)
# 5. Detectar círculos utilizando a Transformada de Hough
circulos = cv2.HoughCircles(
imaxe_gris, # Imaxe en escala de grises
cv2.HOUGH_GRADIENT, # Método de detección
dp=1, # Relación inversa da resolución do acumulador
minDist=imaxe_gris.shape[0] / 8, # Distancia mínima entre os centros dos círculos detectados
param1=150, # Umbral para o detector de bordos (Canny)
param2=80, # Umbral acumulador: evidencia necesaria para declarar un círculo
minRadius=10, # Radio mínimo dos círculos a detectar (0 = sen límite inferior)
maxRadius=0 # Radio máximo dos círculos a detectar (0 = sen límite superior)
)
# 6. Se se detectan círculos, debúxanse sobre a imaxe orixinal
if circulos is not None:
# Redondeamos e convertimos os valores a enteiros
circulos = np.uint16(np.around(circulos))
for i in circulos[0, :]:
# Debuxar o contorno do círculo (en verde)
cv2.circle(imaxe, (i[0], i[1]), i[2], (0, 255, 0), 2)
# Debuxar o centro do círculo (en vermello)
cv2.circle(imaxe, (i[0], i[1]), 2, (0, 0, 255), 3)
else:
print("Non se detectaron círculos na imaxe.")
# 7. Mostrar a imaxe resultante con cv2_imshow (compatible con Google Colab)
cv2_imshow(imaxe)
param2 (limiar acumulador): Este parámetro define canta "evidencia" require o algoritmo para confirmar un círculo. Se detecta demasiados círculos, aumenta o seu valor (por exemplo, de 30 a 40 ou mesmo a 70) para que só se acepten círculos cunha detección moito máis forte.
minDist: Define a distancia mínima entre centros de círculos detectados. Se se repiten deteccións do mesmo círculo ou se xeran solapamentos, incrementa este parámetro para obrigar a que os círculos recoñecidos estean máis separados entre si.
minRadius e maxRadius: Se coñeces aproximadamente o tamaño dos círculos que buscas, establece estes valores para limitar a procura. Isto evita que se detecten círculos demasiado pequenos ou demasiado grandes que poden ser artefactos do proceso.
param1 (limiar Canny): Aínda que non adoita ser a causa principal de múltiples deteccións, aumentar este valor (por exemplo, de 100 a 150) axuda a pasar menos bordos débiles ao algoritmo Canny e, polo tanto, reduce falsos positivos.
import cv2
import numpy as np
from google.colab import files
from google.colab.patches import cv2_imshow
# Subir a imaxe, filtrala, convertela a escala de grises e mostralo
uploaded = files.upload()
for nome_arquivo in uploaded.keys():
imaxe = cv2.imread(nome_arquivo)
imaxe_gris = cv2.cvtColor(imaxe, cv2.COLOR_BGR2GRAY)
imaxe_gris = cv2.medianBlur(imaxe_gris, 5)
cv2_imshow(imaxe_gris)
# Detectar bordos e mostralos
bordos = cv2.Canny(imaxe_gris, 50, 200)
cv2_imshow(bordos)
# Atopar contornos
contornos, _ = cv2.findContours(bordos, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for cnt in contornos:
if cv2.contourArea(cnt) < 120: # Filtrar contornos moi pequenos
continue
# Aproximar a forma para obter os seus vértices
aproximacion = cv2.approxPolyDP(cnt, 0.04 * cv2.arcLength(cnt, True), True)
vertices = len(aproximacion)
# Clasificar a forma segundo a cantidade de vértices
if vertices == 3:
forma = "Triángulo"
elif vertices == 4:
forma = "Rectángulo"
elif vertices == 5:
forma = "Pentágono"
else:
forma = "Círculo"
# Debuxar a forma e a súa etiqueta
cv2.drawContours(imaxe, [aproximacion], 0, (0, 255, 0), 2)
momentos = cv2.moments(cnt)
if momentos["m00"] != 0:
cx = int(momentos["m10"] / momentos["m00"])
cy = int(momentos["m01"] / momentos["m00"])
cv2.putText(imaxe, forma, (cx - 20, cy), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
cv2_imshow(imaxe)
Bordos e contornos: Detéctanse bordos con cv2.Canny e búscanse contornos con cv2.findContours.
Aproximación do polígono: Con cv2.approxPolyDP simplifícase cada contorno para obter os seus vértices.
Clasificación de formas: Segundo o número de vértices, se etiqueta a forma (por exemplo, 3 = triángulo, 4 = rectángulo, máis de 5 = círculo).
Visualización: Debúxanse os contornos e se etiqueta a forma usando cv2.putText e móstrase a imaxe con cv2_imshow.
Con estes mínimos axustes, agora poderás detectar diversas formas en lugar de só círculos.
◦ Obxectivo: Aprender a utilizar imaxes descargadas dunha url e aplicarlle distintos filtros.
◦ Instrución: Baixar a imaxe de Lena e aplicarlle o filtro Gaussian Blur (desenfoque suave) .
import urllib.request Permite que a computadora busque e descargue cousas da internet.
import numpy as np Usa Numpy, que axuda a manexar moitos números rapidamente. As imaxes están formadas por miles de números.
from google.colab.patches import cv2_imshow Prepara unha forma especial de mostrar imaxes en Google Colab.
url = "https://github.com/opencv/opencv/raw/master/samples/data/lena.jpg" Garda a dirección web de onde se atopa a imaxe.
resp = urllib.request.urlopen(url) Abre esa “dirección” na internet para pedir a imaxe.
image_data = np.asarray(bytearray(resp.read()), dtype="uint8") Le o que hai na imaxe e convérteo nunha lista de números que a computadora entende.
imaxe = cv2.imdecode(image_data, cv2.IMREAD_COR) Transforma eses números nunha imaxe con cores, xuntando todas as pezas coma se fose un crebacabezas.
desenfoque = cv2.GaussianBlur(imaxe, (15, 15), 0) Aplica un filtro que “suaviza” a imaxe, facéndoa un pouco borrosa.
cv2_imshow(desenfoque) Mostra a imaxe xa procesada (desenfocada) na pantalla dentro de Colab.
Usar outro tipo de filtros importantes para IA. Este código aplica sucesivos filtros á mesma imaxe.
Agora introduce tí o código necesario para incluir este tamén:( Non esquezas combinar e mostrar a imaxe filtrada)
# 4. Filtro Sharpen (mellora da nitidez)
# Este filtro destaca os bordos e detalla a imaxe, facendo que se vexa máis "crunchy".
kernel_sharpen = np.array([[-1, -1, -1],
[-1, 9, -1],
[-1, -1, -1]])
sharpen = cv2.filter2D(imaxe, -1, kernel_sharpen)
sharpen = engadir_texto(sharpen, "Sharpen")
Esta explicación axudarache a comprender cada paso sen necesidade de saber moito sobre programación.
Imaxina que tes un mosaico feito de moitas pezas de cores pequeniñas, coma se fosen fichas dun crebacabezas. Cada ficha é un píxel da imaxe.
Un filtro blur é coma se en lugar de ver cada ficha individual, mesturases todas as cores dun grupiño de fichas próximas para que se vexan máis suaves.
Agora, pensa no kernel como unha xanela pequena ou un cadrado (por exemplo, de 15 fichas por 15 fichas) que che serve para mirar unha parte da imaxe. Esta "ventanita" móvese por toda a imaxe. En cada paso, recolle as cores de cada ficha dentro desa xanela, os mestura (coma se fixeses un batido de cores) e logo coloca esa cor mesturada no centro.
Para resumir de forma visual e sinxela:
import cv2 import urllib.request import numpy as np from google.colab.patches import cv2_imshow # URL dunha imaxe libre (neste caso, a clásica "Lena" de OpenCV).Podes cambiala por calquera outra url = "https://github.com/opencv/opencv/raw/master/samples/data/lena.jpg" # Descargo e decodifico a imaxe. Mostroa co valor inicial resp = urllib.request.urlopen(url) datos_imaxe = np.asarray(bytearray(resp.read()), dtype="uint8") imaxe = cv2.imdecode(datos_imaxe, cv2.IMREAD_COLOR) #cv2_imshow(imaxe) #Se quero mostrar a imaxe inicial # Aplico filtro de desenfoque (Gaussian Blur) cun kernel de (15, 15) desenfoque = cv2.GaussianBlur(imaxe, (15, 15), 0) # Mostro a imaxe desenfocada usando cv2_imshow (compatible con Colab) #cv2_imshow(desenfoque) #Se quero mostrar a imaxe desenfocada # Creo unha imaxe con ambas unha ó lado da outra e móstroas xuntas para ver os cambios imaxe_concatenada = cv2.hconcat([imaxe, desenfoque]) cv2_imshow(imaxe_concatenada)
Filtros usados:
Gaussian Blur: Suaviza a imaxe coma se difumbras a foto cun pincel suave.
Median Blur: Substitúe cada píxel por un valor que representa o "centro" dos seus veciños, útil para quitar manchas puntuais (ruído).
Bilateral Filter: Suaviza a imaxe pero mantén os bordos ben definidos, perfecto para resaltar o importante sen perder contornos.
Sharpen (Nitidez): Aumenta os contrastes dos bordos para que a imaxe véxase máis definida, coma se déseslle un toque “nítido”. Suaviza a imaxe sen perder o detalle dos bordos.
Non existe un filtro único que sexa "o máis importante" en todos os casos; cada un utilízase segundo o que necesitemos facer coa imaxe. Outros que te vas a atopar:
Filtro Canny: É moi útil para resaltar os bordos e ver os contornos dos obxectos, por iso úsase moito en aplicacións de visión por computadora.
Filtro Sobel: Tamén se usa para detectar bordos, pero ademais calcula a dirección na que cambian as cores ou a intensidade. É parecido a descubrir por onde se inclina unha liña nunha foto.
Filtro Laplaciano: Leste filtro axuda a destacar as zonas onde a imaxe cambia bruscamente. É moi bo para detectar detalles finos e é outra forma de resaltar os bordos.
No mundo da IA moderna, as redes neuronais (especialmente as convolucionales) aprenden os seus propios filtros de forma automática a partir dos datos.
Con todo, coñecer estes filtros clásicos (Canny, Sobel, Laplaciano etc.)/ etc.) axúdache a entender como a computadora ve e procesa as imaxes. Cada filtro ten a súa función e, segundo o problema que desexas
resolver, pode ser tan esencial como o outro.
Para variar o kernel neste programa, podes modificar os valores do tamaño do kernel en cada filtro.
Os kernels controlan a intensidade e o alcance da operación aplicada.
Aquí tes exemplos para facer isto:
Filtro Gaussian Blur
O tamaño do kernel é especificado como unha tupla, por exemplo, (15, 15). Podes substituílo por outro valor como (30, 30) para aumentar o efecto de desenfoque.
Filtro Median Blur
O tamaño do kernel é un número impar. Podes cambiar o valor de 15 a outro número impar como 21 ou 25.
Filtro Bilateral
No filtro bilateral, podes variar os parámetros d, sigmaColor, e sigmaSpace. d controla o tamaño do vecindario. sigmaColor afecta á intensidade da suavización das cores. sigmaSpace define o alcance espacial.
Exemplo: bilateral = cv2.bilateralFilter(imaxe, d=25, sigmaColor=100, sigmaSpace=100)
Filtro Sharpen
O filtro de nitidez usa un kernel personalizado. Podes modificar os valores dentro da matriz do kernel para cambiar o efecto:
kernel_sharpen = np.array([[-1, -1, -1],
[-1, 10, -1],
[-1, -1, -1]])
sharpen = cv2.filter2D(imaxe, -1, kernel_sharpen)
Licenciado baixo a Licenza Creative Commons Atribución Compartir igual 4.0