sol Filtros de Convolução

Objetivos da aula:

• Conhecer processo generico de filtro de convolução
• conhecer os filtros de blurring (suavização)
• conhecer o filtro de sharpening (realce)
• conhecer o detetor linhas de canny

Filtro de convolução

O filtro de convolução é um nomes dados para filtragem no domínio espacial. Esse processo ocorre com a aplicação de filtros (pequenas matrizes), posicionados sob cada pixel da imagem. Estes filtros, normalmente, são chamados de kernels (ou núcleos). O resultado final do valor do pixel é calculado através de um produto de convolução.

Normalmente os kernels são matrizes 3x3, 5x5 ou 7x7.

Desafio 0¶

Abra o link https://setosa.io/ev/image-kernels/ e de forma intuitiva altere o valor do filtro/kernel e descubra efeitos resultantes.

In [ ]:

# fazendo o download das imagens necessárias para o lab

!wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/convolution.png /content
!wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/lena.png /content
!wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/saida.png /content
!wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/same_padding_no_strides.gif /content
!wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/tux.png /content

# fazendo o download das imagens necessárias para o lab !wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/convolution.png /content !wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/lena.png /content !wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/saida.png /content !wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/same_padding_no_strides.gif /content !wget https://raw.githubusercontent.com/arnaldojr/cognitivecomputing/master/material/aulas/PDI/lab04/tux.png /content

In [1]:

%matplotlib inline
import cv2
from matplotlib import pyplot as plt
import numpy as np

img = cv2.imread('convolution.png')
plt.imshow(img); plt.show()

%matplotlib inline import cv2 from matplotlib import pyplot as plt import numpy as np img = cv2.imread('convolution.png') plt.imshow(img); plt.show()

In [2]:

from IPython.display import Image
Image(open('same_padding_no_strides.gif','rb').read())

from IPython.display import Image Image(open('same_padding_no_strides.gif','rb').read())

Out[2]:

Observação

Embora o nome convolução seja muito usado, na prática realizamos o processo de correlação, para realizar a convolução é necessário realizar a inversão da mascara (matriz), o que não é um problema pois em processamento de imagem, tipicamente os kernels são simétricos, logo os resultados de convolução e correlação não mudam.

Implementação na OpenCV¶

Podemos implementar o produto de convolução montando uma estrutura com dois for para varrer a imagem toda, pixel-a-pixel.Não é a forma mais eficiente, pois Na OpenCV tem uma função built-in para implementação de filtro de convolução a cv2.filter2D()

In [3]:

import numpy as np
import cv2


#carrega imagem
img = cv2.imread('lena.png')
plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show()

# Define o kernel
kernel = np.array([[1, 1, 1, 1, 1], 
                   [1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1],
                   [1, 1, 1, 1 ,1]])
kernel = kernel/(np.sum(kernel) if np.sum(kernel)!=0 else 1)

# Realiza o produto de convolução
imgf = cv2.filter2D(img,-1,kernel)

#exibe resultado filtrado
plt.imshow(imgf, cmap="Greys_r", vmin=0, vmax=255); plt.show()

import numpy as np import cv2 #carrega imagem img = cv2.imread('lena.png') plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show() # Define o kernel kernel = np.array([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1 ,1]]) kernel = kernel/(np.sum(kernel) if np.sum(kernel)!=0 else 1) # Realiza o produto de convolução imgf = cv2.filter2D(img,-1,kernel) #exibe resultado filtrado plt.imshow(imgf, cmap="Greys_r", vmin=0, vmax=255); plt.show()

FILTROS PARA BLURRING

O filtro de blurring (borramento) consiste na perda gradual de foco da imagem, produzindo a sensação que ela está borrada. Em outras palavras são filtros passa-baixa.

Existem diversos métodos para construções de kernels para blurring:

• filtro da média (box filter): blur = cv.blur(img,(5,5))
• filtro gaussiano: blur = cv.GaussianBlur(img,(5,5),0)
• filtro da mediana: blur = cv.medianBlur(img,5)
• filtro bilateral: blur = cv.bilateralFilter(img,9,75,75)

In [4]:

import numpy as np
import cv2 

#carrega imagem
img = cv2.imread('lena.png')
plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show()

# Realiza o blur
imgf = cv2.blur(img,(51,51),0)

#exibe resultado filtrado
plt.imshow(imgf, cmap="Greys_r", vmin=0, vmax=255); plt.show()

import numpy as np import cv2 #carrega imagem img = cv2.imread('lena.png') plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show() # Realiza o blur imgf = cv2.blur(img,(51,51),0) #exibe resultado filtrado plt.imshow(imgf, cmap="Greys_r", vmin=0, vmax=255); plt.show()

Desafio 1¶

Escolha uma imagem da sua preferência e faça um estudo sobre os diferentes tipos de filtros de borramento, analise também o que acontece quando é alterado o tamanho do kernel.

In [5]:

#Implemente seu código aqui.

# Como a ideia é realizar um estudo para entender o efeito de diferentes filtros, vou realizar a mesma operação para diferentes tamanhos de kernel.
# Vou utilizar um filtro de média, um filtro gaussiano, um filtro de mediana e um filtro bilateral. 
# Vou exibir os resultados para cada tamanho de kernel. 
# Por essa razão, vou criar uma figura com subplots para exibir os resultados e varrer os diferentes tamanhos de kernel utilizando um loop for.

# É apenas uma sugestão de abordagem, você pode implementar de outra forma se preferir.


import cv2
from matplotlib import pyplot as plt

# Carrega a imagem
img = cv2.imread('lena.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Define os tamanhos de kernel para experimentação
kernels = [(5, 5), (15, 15), (51, 51)]

# Cria uma figura com subplots
fig, axs = plt.subplots(len(kernels) + 1, 4, figsize=(20, 15))

# Exibe a imagem original
axs[0, 0].imshow(img)
axs[0, 0].set_title('Imagem Original')
for i in range(1, 4):
    axs[0, i].axis('off')

# Aplica e exibe os diferentes filtros para cada tamanho de kernel
for i, kernel in enumerate(kernels, 1):
    # Filtro de Média
    img_blur = cv2.blur(img, kernel)
    axs[i, 0].imshow(img_blur)
    axs[i, 0].set_title(f'Filtro de Média - Kernel {kernel}')

    # Filtro Gaussiano
    img_gaussian = cv2.GaussianBlur(img, kernel, 0)
    axs[i, 1].imshow(img_gaussian)
    axs[i, 1].set_title(f'Filtro Gaussiano - Kernel {kernel}')

    # Filtro de Mediana
    img_median = cv2.medianBlur(img, kernel[0])  # O kernel é um único valor para o filtro de mediana
    axs[i, 2].imshow(img_median)
    axs[i, 2].set_title(f'Filtro de Mediana - Kernel {kernel[0]}')

    # Filtro Bilateral
    img_bilateral = cv2.bilateralFilter(img, 9, 75, 75)
    axs[i, 3].imshow(img_bilateral)
    axs[i, 3].set_title(f'Filtro Bilateral - D=9, SigmaColor=75, SigmaSpace=75')

# Ajusta o layout e exibe a figura
plt.tight_layout()
plt.show()

#Implemente seu código aqui. # Como a ideia é realizar um estudo para entender o efeito de diferentes filtros, vou realizar a mesma operação para diferentes tamanhos de kernel. # Vou utilizar um filtro de média, um filtro gaussiano, um filtro de mediana e um filtro bilateral. # Vou exibir os resultados para cada tamanho de kernel. # Por essa razão, vou criar uma figura com subplots para exibir os resultados e varrer os diferentes tamanhos de kernel utilizando um loop for. # É apenas uma sugestão de abordagem, você pode implementar de outra forma se preferir. import cv2 from matplotlib import pyplot as plt # Carrega a imagem img = cv2.imread('lena.png') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # Define os tamanhos de kernel para experimentação kernels = [(5, 5), (15, 15), (51, 51)] # Cria uma figura com subplots fig, axs = plt.subplots(len(kernels) + 1, 4, figsize=(20, 15)) # Exibe a imagem original axs[0, 0].imshow(img) axs[0, 0].set_title('Imagem Original') for i in range(1, 4): axs[0, i].axis('off') # Aplica e exibe os diferentes filtros para cada tamanho de kernel for i, kernel in enumerate(kernels, 1): # Filtro de Média img_blur = cv2.blur(img, kernel) axs[i, 0].imshow(img_blur) axs[i, 0].set_title(f'Filtro de Média - Kernel {kernel}') # Filtro Gaussiano img_gaussian = cv2.GaussianBlur(img, kernel, 0) axs[i, 1].imshow(img_gaussian) axs[i, 1].set_title(f'Filtro Gaussiano - Kernel {kernel}') # Filtro de Mediana img_median = cv2.medianBlur(img, kernel[0]) # O kernel é um único valor para o filtro de mediana axs[i, 2].imshow(img_median) axs[i, 2].set_title(f'Filtro de Mediana - Kernel {kernel[0]}') # Filtro Bilateral img_bilateral = cv2.bilateralFilter(img, 9, 75, 75) axs[i, 3].imshow(img_bilateral) axs[i, 3].set_title(f'Filtro Bilateral - D=9, SigmaColor=75, SigmaSpace=75') # Ajusta o layout e exibe a figura plt.tight_layout() plt.show()

FILTRO DE SHARPENING

O filtro de sharpening consiste no ganho gradual de foco de uma imagem, produzindo a sensação que ela está cada vez mais bem definida. É uma aproximação da inversa do filtro de blurring.

Existem diversos métodos para construções de kernels para blurring:

• filtro Sobel X: imgf = cv.Sobel(img,cv.CV_64F,1,0,ksize=5)
• filtro Sobel Y: imgf = cv.Sobel(img,cv.CV_64F,0,1,ksize=5)
• filtro Laplaciano: imgf = cv.Laplacian(img,cv.CV_64F)

Abaixo, temos as formas matriciais do filtro de sharpening.

In [6]:

#Filtro Laplaciano
kernel = np.array([[0, -1, 0], 
                   [-1, 4, -1], 
                   [0, -1, 0]])

kernel = np.array([[-1, -1, -1], 
                   [-1, 8, -1], 
                   [-1, -1, -1]])
#filtro de Sobel X
kernel = np.array([[-1, 0, 1], 
                   [-2, 0, 2], 
                   [-1, 0, 1]])
kernel = np.array([[-1, -2, -1], 
                   [ 0, 0, 0], 
                   [-1, 0, 1]])

#Filtro Laplaciano kernel = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]]) kernel = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]]) #filtro de Sobel X kernel = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) kernel = np.array([[-1, -2, -1], [ 0, 0, 0], [-1, 0, 1]])

In [7]:

import numpy as np
import cv2


#carrega imagem
img = cv2.imread('lena.png')
plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show()



imgf = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
imgf2 = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)

# Monta o kernel filtro 
#kernel = np.array([[-1, -1, -1], 
#                   [-1, 8, -1], 
#                   [-1, -1, -1]])
# Realiza o produto de convolução
#imgf = cv2.filter2D(img,-1,kernel)

#exibe resultado filtrado
plt.imshow(imgf, cmap="Greys_r", vmin=0, vmax=255);plt.show()
plt.imshow(imgf2, cmap="Greys_r", vmin=0, vmax=255); plt.show()

import numpy as np import cv2 #carrega imagem img = cv2.imread('lena.png') plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show() imgf = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3) imgf2 = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3) # Monta o kernel filtro #kernel = np.array([[-1, -1, -1], # [-1, 8, -1], # [-1, -1, -1]]) # Realiza o produto de convolução #imgf = cv2.filter2D(img,-1,kernel) #exibe resultado filtrado plt.imshow(imgf, cmap="Greys_r", vmin=0, vmax=255);plt.show() plt.imshow(imgf2, cmap="Greys_r", vmin=0, vmax=255); plt.show()

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

Desafio 2¶

Escolha uma imagem da sua preferência e faça um estudo sobre os diferentes tipos de filtros de contraste, analise também o que acontece quando é alterado o tamanho do kernel.

In [10]:

#implemente seu código aqui.

# Aqui, a ideia é realizar um estudo para entender o efeito de diferentes filtros.
# Vou aplicar o filtro Sobel e o filtro Laplaciano para diferentes tamanhos de kernel.
# Vou exibir os resultados para cada tamanho de kernel.
# Por essa razão, vou criar uma figura com subplots para exibir os resultados e varrer os diferentes tamanhos de kernel utilizando um loop for.

# É apenas uma sugestão de abordagem, você pode implementar de outra forma se preferir.


import cv2
import numpy as np
from matplotlib import pyplot as plt

# Carrega a imagem
img = cv2.imread('lena.png', cv2.IMREAD_GRAYSCALE)

# Define os tamanhos de kernel para experimentação
kernels = [3, 13, 21]

# Cria uma figura com subplots
fig, axs = plt.subplots(len(kernels), 2, figsize=(10, len(kernels) * 5))

# Aplica e exibe os diferentes filtros para cada tamanho de kernel
for i, kernel_size in enumerate(kernels):
    # Filtro Sobel
    sobel_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=kernel_size)
    sobel_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=kernel_size)
    sobel = np.sqrt(sobel_x**2 + sobel_y**2) # Sugestão, combinar as respostas dos filtros em x e y para obter o módulo do gradiente da imagem, que é mais informativo que as respostas individuais dos filtros em x e y 
    axs[i, 0].imshow(sobel, cmap='gray')
    axs[i, 0].set_title(f'Filtro Sobel - Kernel {kernel_size}x{kernel_size}')

    # Filtro Laplaciano
    laplacian = cv2.Laplacian(img, cv2.CV_64F, ksize=kernel_size)
    axs[i, 1].imshow(laplacian, cmap='gray')
    axs[i, 1].set_title(f'Filtro Laplaciano - Kernel {kernel_size}x{kernel_size}')

# Ajusta o layout e exibe a figura
plt.tight_layout()
plt.show()

#implemente seu código aqui. # Aqui, a ideia é realizar um estudo para entender o efeito de diferentes filtros. # Vou aplicar o filtro Sobel e o filtro Laplaciano para diferentes tamanhos de kernel. # Vou exibir os resultados para cada tamanho de kernel. # Por essa razão, vou criar uma figura com subplots para exibir os resultados e varrer os diferentes tamanhos de kernel utilizando um loop for. # É apenas uma sugestão de abordagem, você pode implementar de outra forma se preferir. import cv2 import numpy as np from matplotlib import pyplot as plt # Carrega a imagem img = cv2.imread('lena.png', cv2.IMREAD_GRAYSCALE) # Define os tamanhos de kernel para experimentação kernels = [3, 13, 21] # Cria uma figura com subplots fig, axs = plt.subplots(len(kernels), 2, figsize=(10, len(kernels) * 5)) # Aplica e exibe os diferentes filtros para cada tamanho de kernel for i, kernel_size in enumerate(kernels): # Filtro Sobel sobel_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=kernel_size) sobel_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=kernel_size) sobel = np.sqrt(sobel_x**2 + sobel_y**2) # Sugestão, combinar as respostas dos filtros em x e y para obter o módulo do gradiente da imagem, que é mais informativo que as respostas individuais dos filtros em x e y axs[i, 0].imshow(sobel, cmap='gray') axs[i, 0].set_title(f'Filtro Sobel - Kernel {kernel_size}x{kernel_size}') # Filtro Laplaciano laplacian = cv2.Laplacian(img, cv2.CV_64F, ksize=kernel_size) axs[i, 1].imshow(laplacian, cmap='gray') axs[i, 1].set_title(f'Filtro Laplaciano - Kernel {kernel_size}x{kernel_size}') # Ajusta o layout e exibe a figura plt.tight_layout() plt.show()

FILTRO DE BORDAS DE CANNY

O filtro de canny é um detector de linhas e bordas que combina de forma mais sofisticada operações lineares.

In [ ]:

import numpy as np
import cv2


#carrega imagem
img = cv2.imread('lena.png')
plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show()

min_contrast = 50
max_contrast = 200

imgfb = cv2.GaussianBlur(img,(5,5),0)
imgf = cv2.Canny(imgfb, min_contrast, max_contrast )

plt.imshow(imgf,cmap="Greys_r", vmin=0, vmax=255); plt.show()

import numpy as np import cv2 #carrega imagem img = cv2.imread('lena.png') plt.imshow(img, cmap="Greys_r", vmin=0, vmax=255); plt.show() min_contrast = 50 max_contrast = 200 imgfb = cv2.GaussianBlur(img,(5,5),0) imgf = cv2.Canny(imgfb, min_contrast, max_contrast ) plt.imshow(imgf,cmap="Greys_r", vmin=0, vmax=255); plt.show()

Desafio 3¶

O Filtro de Canny é um dos mais utilizados até hoje, por ser robusto e apresentar bons resultados. Implemente o detector de bordas de canny e analise os efeitos alterandos os valores de threshold.

In [11]:

#Seu código

import cv2
import numpy as np
from matplotlib import pyplot as plt

# Carrega a imagem
img = cv2.imread('lena.png', cv2.IMREAD_GRAYSCALE)

# Define os pares de valores de threshold para experimentação no detector de bordas de Canny, 
# onde cada par é um conjunto de valores para os thresholds mínimo e máximo
# A ideia é experimentar diferentes valores para os thresholds e observar o efeito no resultado
thresholds = [(50, 100), (100, 150), (150, 200)]

# Cria uma figura com subplots
fig, axs = plt.subplots(1, len(thresholds), figsize=(15, 5))

# Aplica e exibe o detector de bordas de Canny para cada par de thresholds
for i, (low_threshold, high_threshold) in enumerate(thresholds):
    # Detector de bordas de Canny
    edges = cv2.Canny(img, low_threshold, high_threshold)
    axs[i].imshow(edges, cmap='gray')
    axs[i].set_title(f'Canny - Thresholds: ({low_threshold}, {high_threshold})')

# Ajusta o layout e exibe a figura
plt.tight_layout()
plt.show()

#Seu código import cv2 import numpy as np from matplotlib import pyplot as plt # Carrega a imagem img = cv2.imread('lena.png', cv2.IMREAD_GRAYSCALE) # Define os pares de valores de threshold para experimentação no detector de bordas de Canny, # onde cada par é um conjunto de valores para os thresholds mínimo e máximo # A ideia é experimentar diferentes valores para os thresholds e observar o efeito no resultado thresholds = [(50, 100), (100, 150), (150, 200)] # Cria uma figura com subplots fig, axs = plt.subplots(1, len(thresholds), figsize=(15, 5)) # Aplica e exibe o detector de bordas de Canny para cada par de thresholds for i, (low_threshold, high_threshold) in enumerate(thresholds): # Detector de bordas de Canny edges = cv2.Canny(img, low_threshold, high_threshold) axs[i].imshow(edges, cmap='gray') axs[i].set_title(f'Canny - Thresholds: ({low_threshold}, {high_threshold})') # Ajusta o layout e exibe a figura plt.tight_layout() plt.show()

FILTRO DE LIMIARIZAÇÃO

O filtro de limiariazação é converte uma imagem em tons de ciza para uma imagem binaria.

Podemos utilizar diversas tecnicas de limiarização, cada um com sua particularidade, leia a documentação para mais detalhes:

cv2.THRESH_BINARY cv2.THRESH_BINARY_INV cv2.THRESH_TRUNC cv2.THRESH_TOZERO cv2.THRESH_TOZERO_INV cv2.THRESH_OTSU

In [12]:

import numpy as np
import cv2


#carrega imagem
image = cv2.imread('lena.png')
img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
plt.imshow(img,cmap="Greys_r", vmin=0, vmax=255); plt.show()


ret3,th3 = cv2.threshold(img,0,255,cv2.THRESH_OTSU)

plt.imshow(th3,cmap="Greys_r", vmin=0, vmax=255); plt.show()

import numpy as np import cv2 #carrega imagem image = cv2.imread('lena.png') img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) plt.imshow(img,cmap="Greys_r", vmin=0, vmax=255); plt.show() ret3,th3 = cv2.threshold(img,0,255,cv2.THRESH_OTSU) plt.imshow(th3,cmap="Greys_r", vmin=0, vmax=255); plt.show()

FILTRO DE SOBREPOSIÇÃO DE IMAGENS

O filtro de sobreposição mescla duas imagens gerando efeito de sobreposição, ou Blending.

A operação da imagem de saida é a seguinte: g(x)=(1−α)∗f0(x)+α∗f1(x)

In [ ]:

import numpy as np
import cv2

alpha = 0.8
beta = (1.0 - alpha)

src1 = cv2.imread("lena.png")
src2 = cv2.imread("tux.png")
src2= cv2.cvtColor(src2, cv2.COLOR_BGR2RGB )

src2 = cv2.resize(src2, src1.shape[1::-1])
print(src1.shape, src2.shape)


dst = cv2.addWeighted(src1, alpha, src2, beta, 0.0)


plt.imshow(src1); plt.show()
plt.imshow(src2); plt.show()
plt.imshow(dst); plt.show()

import numpy as np import cv2 alpha = 0.8 beta = (1.0 - alpha) src1 = cv2.imread("lena.png") src2 = cv2.imread("tux.png") src2= cv2.cvtColor(src2, cv2.COLOR_BGR2RGB ) src2 = cv2.resize(src2, src1.shape[1::-1]) print(src1.shape, src2.shape) dst = cv2.addWeighted(src1, alpha, src2, beta, 0.0) plt.imshow(src1); plt.show() plt.imshow(src2); plt.show() plt.imshow(dst); plt.show()

(512, 512, 3) (512, 512, 3)

Desafio 4¶

O filtro de sobel calcula a primeira derivada, isso pode ser feito na direção de X ou em Y. Faça uma implementação que junta os efeitos das duas derivadas de sobel

In [13]:

#Seu código aqui.

# No desafio 2 do lab, eu sugeri a aplicação do filtro de sobel com essa junção de respostas para obter o módulo do gradiente da imagem.
# Vou aplicar o filtro de sobel e exibir o resultado para a imagem lena.png.

import cv2
import numpy as np
from matplotlib import pyplot as plt

# Carrega a imagem
img = cv2.imread('lena.png', cv2.IMREAD_GRAYSCALE)

# Filtro Sobel
sobel_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3)
sobel = np.sqrt(sobel_x**2 + sobel_y**2)

# Exibe o resultado
plt.imshow(sobel, cmap='gray')
plt.title('Filtro Sobel - Módulo do Gradiente')
plt.show()

#Seu código aqui. # No desafio 2 do lab, eu sugeri a aplicação do filtro de sobel com essa junção de respostas para obter o módulo do gradiente da imagem. # Vou aplicar o filtro de sobel e exibir o resultado para a imagem lena.png. import cv2 import numpy as np from matplotlib import pyplot as plt # Carrega a imagem img = cv2.imread('lena.png', cv2.IMREAD_GRAYSCALE) # Filtro Sobel sobel_x = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3) sobel_y = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3) sobel = np.sqrt(sobel_x**2 + sobel_y**2) # Exibe o resultado plt.imshow(sobel, cmap='gray') plt.title('Filtro Sobel - Módulo do Gradiente') plt.show()