RELATÓRIO DE EXECUÇÃO DE ATIVIDADE

1
Icev– Instituto de Ensino Superior
64.055-260 – Teresina – PI – Brasil

1. Resumo
Este relatório apresenta um estudo completo sobre o processamento de imagens,
dividido em três seções distintas. Na primeira parte, realizamos uma série de operações
na imagem “lena.png", como redimensionamento, conversão para o espaço de cores
HSV, análise do histograma em cores e escala de cinza, além da equalização. Também
exploramos a exibição dos canais de cores separadamente.
A segunda parte concentra-se na manipulação da imagem “imagem.png". Nessa seção,
implementamos técnicas para preencher espaços vazios em objetos pretos, remover
exclusivamente objetos pretos, preencher espaços vazios em objetos coloridos (azul,
amarelo e verde) e realçar as bordas na imagem.
Na terceira parte, aplicamos o processamento de imagens a três imagens diferentes:
“lena_ruido.png", “coins.png” e “margaridas.png". Utilizamos o filtro da Mediana para
reduzir o ruído na imagem “lena_ruido.png". Para a imagem “coins.png", aplicamos os
filtros Sobel e Prewitt para detectar as bordas. Por fim, exploramos a segmentação das
imagens na imagem “margaridas.png” criando retângulos e aplicando métodos de
binarização em cada região.
Esse estudo demonstra a aplicação de várias técnicas de processamento de imagens para
melhorar a qualidade das imagens, realçar características específicas e extrair
informações valiosas. Cada seção do trabalho é discutida detalhadamente com
resultados e insights apresentados.

2. Parte I
A Parte I deste estudo de processamento de imagens concentra-se nas operações
aplicadas à imagem "lena.png". O objetivo principal desta seção é introduzir e explorar
as técnicas fundamentais de processamento de imagens, demonstrando sua aplicação na
manipulação e melhoria da qualidade de uma imagem.
As operações realizadas nesta parte incluem o redimensionamento da imagem para
diferentes tamanhos, a conversão para o espaço de cores HSV para análise mais
detalhada das características de cores, a geração de histogramas tanto em cores quanto
em escala de cinza para compreender a distribuição de intensidade de pixels e, por fim,
a equalização do histograma para melhorar o contraste e a visibilidade das
características da imagem.
Ao detalhar cada uma dessas etapas, este resumo destaca o propósito e a importância de
cada operação na preparação da imagem para análise posterior. A Parte I serve como
uma base crucial para a compreensão das técnicas avançadas de processamento de
imagens que serão abordadas nas partes subsequentes deste estudo.
2.1 Utilizamos o seguinte código para redimensionar a imagem:
- cv2.imread(caminho_imagem): Carrega uma imagem do caminho especificado e
armazena na variável imagem.
- cv2.resize(imagem, (1024, 1024)): Redimensiona a imagem para o tamanho
especificado (1024x1024 pixels) e armazena na variável imagem_redimensionada.
- cv2.imshow('Imagem Redimensionada', imagem_redimensionada): Exibe a imagem
redimensionada em uma janela com o título 'Imagem Redimensionada'.
- cv2.imwrite('imagem_redimensionada.jpg', imagem_redimensionada): Salva a
imagem redimensionada como 'imagem_redimensionada.jpg' no disco.
- cv2.imshow('Imagem Original', imagem): Exibe a imagem original em uma janela
com o título 'Imagem Original'.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
Temos a seguir uma captura de tela mostrando a imagem original e a mesma
redimensionada:

2.2 Utilizamos o seguinte código para conversão para HSV:

- cv2.imread(caminho_imagem): Carrega uma imagem do caminho especificado e
armazena na variável imagem.

- cv2.cvtColor(imagem, cv2.COLOR_BGR2HSV): Converte a imagem da

representação de cores BGR para HSV e armazena na variável imagem_hsv.

- cv2.imwrite('imagem_hsv.jpg', imagem_hsv): Salva a imagem convertida (HSV)

como 'imagem_hsv.jpg' no disco.

- cv2.imshow('Imagem HSV', imagem_hsv): Exibe a imagem convertida em uma janela

com o título 'Imagem HSV'.

- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar a janela da imagem.
Temos a seguir uma captura de tela mostrando a imagem original e a mesma
convertida para HSV:

2.3 Utilizamos o seguinte código para gerar o histograma colorido:

- cv2.split(caminho_imagem): Divide a imagem especificada em seus canais de cores
(azul, verde e vermelho) e armazena cada canal em variáveis separadas: canal_azul,
canal_verde e canal_vermelho.
- plt.hist(canal_azul.ravel(), bins=256, color='blue', alpha=0.5): Cria um histograma do
canal azul da imagem, utilizando 256 intervalos (bins) e representa o histograma na cor
azul com uma transparência de 0.5.
- plt.hist(canal_verde.ravel(), bins=256, color='green', alpha=0.5): Cria um histograma
do canal verde da imagem, utilizando 256 intervalos (bins) e representa o histograma na
cor verde com uma transparência de 0.5.
- plt.hist(canal_vermelho.ravel(), bins=256, color='red', alpha=0.5): Cria um histograma
do canal vermelho da imagem, utilizando 256 intervalos (bins) e representa o
histograma na cor vermelha com uma transparência de 0.5.
- plt.xlabel('Intensidade de cor'): Define o rótulo do eixo x do gráfico como 'Intensidade
de cor'.
- plt.ylabel('Número de pixels'): Define o rótulo do eixo y do gráfico como 'Número de
pixels'.
- plt.legend(['Canal Azul', 'Canal Verde', 'Canal Vermelho']): Adiciona uma legenda ao
gráfico para identificar cada canal de cor.
- plt.title('Histograma Colorido'): Define o título do gráfico como 'Histograma
Colorido'.
- plt.show(): Exibe o gráfico do histograma colorido na tela.

Temos o seguinte resultado do histograma colorido:

2.4 Utilizamos o seguinte código para gerar o histograma em escala de cinza:

- cv2.cvtColor(caminho_imagem, cv2.COLOR_BGR2GRAY): Converte a imagem

especificada de sua representação de cores BGR para escala de cinza (grayscale) e
armazena a imagem em tons de cinza em uma variável chamada imagem_cinza.
- plt.hist(imagem_cinza.ravel(), bins=256, color='gray', alpha=0.5): Cria um histograma
da intensidade de cinza da imagem em tons de cinza. Utiliza 256 intervalos (bins) e
representa o histograma na cor cinza com uma transparência de 0.5.
- plt.xlabel('Intensidade de cinza'): Define o rótulo do eixo x do gráfico como
'Intensidade de cinza'.
- plt.ylabel('Número de pixels'): Define o rótulo do eixo y do gráfico como 'Número de
pixels'.
- plt.title('Histograma em Escala de Cinza'): Define o título do gráfico como
'Histograma em Escala de Cinza'.
- plt.show(): Exibe o gráfico do histograma em escala de cinza na tela.
Temos o seguinte resultado do histograma em escala de cinza:

2.5 Utilizamos o seguinte código para equalizar a imagem:

- cv2.imread(caminho_imagem): Carrega uma imagem colorida do caminho

especificado e a armazena na variável imagem_colorida.
- cv2.split(imagem_colorida): Divide a imagem colorida em seus canais de cores (azul,
verde e vermelho) e armazena cada canal em variáveis separadas: canal_azul,
canal_verde e canal_vermelho.
- cv2.equalizeHist(canal_azul): Equaliza o histograma do canal azul da imagem para
melhorar o contraste nesse canal e armazena o resultado em canal_azul_equalizado.
- cv2.equalizeHist(canal_verde): Equaliza o histograma do canal verde da imagem para
melhorar o contraste nesse canal e armazena o resultado em canal_verde_equalizado.
- cv2.equalizeHist(canal_vermelho): Equaliza o histograma do canal vermelho da
imagem para melhorar o contraste nesse canal e armazena o resultado em
canal_vermelho_equalizado.
cv2.merge((canal_azul_equalizado,canal_verde_equalizado,canal_vermelho_equalizado
)): Combina os canais equalizados (azul, verde e vermelho) de volta para criar uma
imagem equalizada completa, armazenada em imagem_equalizada.
- cv2.imshow('Imagem Original', imagem_colorida): Exibe a imagem original em uma
janela com o título 'Imagem Original'.
- cv2.imshow('Imagem Equalizada', imagem_equalizada): Exibe a imagem equalizada
em uma janela com o título 'Imagem Equalizada'.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.
Temos o seguinte resultado da imagem equalizada e a imagem original:
2.6 Utilizamos o seguinte código para exibis os canis de cores separadamente:

- cv2.imread(caminho_imagem): Carrega uma imagem do caminho especificado e a

armazena na variável imagem.
- cv2.cvtColor(imagem, cv2.COLOR_BGR2HSV): Converte a imagem da
representação de cores BGR para a representação HSV e armazena na variável
imagem_hsv.
- imagem_hsv[:, :, 0]: Isola o canal H (Matiz) da imagem HSV e armazena em canal_h.
- imagem_hsv[:, :, 1]: Isola o canal S (Saturação) da imagem HSV e armazena em
canal_s.
- imagem_hsv[:, :, 2]: Isola o canal V (Valor) da imagem HSV e armazena em canal_v.
- np.zeros_like(canal_h): Cria uma matriz de zeros com as mesmas dimensões que o
canal H e armazena em zeros.
- cv2.merge([canal_h, zeros, zeros]): Combina o canal H com os canais S e V
preenchidos com zeros, criando uma imagem em tons de vermelho representando o
canal H e armazena em canal_h_bgr.
- cv2.merge([zeros, canal_s, zeros]): Combina o canal S com os canais H e V
preenchidos com zeros, criando uma imagem em tons de verde representando o canal S
e armazena em canal_s_bgr.
- cv2.merge([zeros, zeros, canal_v]): Combina o canal V com os canais H e S
preenchidos com zeros, criando uma imagem em tons de azul representando o canal V e
armazena em canal_v_bgr.
- cv2.imshow('Canal H', canal_h_bgr): Exibe a imagem do canal H em uma janela com
o título 'Canal H'.
- cv2.imshow('Canal S', canal_s_bgr): Exibe a imagem do canal S em uma janela com o
título 'Canal S'.
- cv2.imshow('Canal V', canal_v_bgr): Exibe a imagem do canal V em uma janela com
o título 'Canal V'.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.
Temos o seguinte resultado das imagens com os canais de cores separadamente:

3. Parte II

Na Parte II deste trabalho, o objetivo é processar a imagem.png fornecida.

Primeiramente, realizamos o preenchimento de todos os buracos presentes nos objetos
pretos, tornando-os sólidos. Em seguida, procedemos à eliminação de todos os objetos
que são de cor preta na imagem, mantendo apenas os objetos coloridos (azul, amarelo e
verde). Posteriormente, preenchemos os eventuais buracos existentes nos objetos
coloridos para garantir sua completude. Por fim, aplicamos uma operação para realçar
as bordas da imagem, tornando-as mais visíveis e destacadas, o que pode ser útil em
diversas aplicações de processamento de imagem. Esse processo visa aprimorar e
segmentar a imagem original para análises subsequentes.
3.1 Utilizamos o seguinte código para preencher todos os buracos dos objetos
pretos:
- cv2.imread('C:/Users/ricar/Desktop/trabalhoimagens/parte1imagens/imagem.png',
cv2.IMREAD_COLOR): Carrega uma imagem colorida do caminho especificado e a
armazena na variável imagem_colorida.
- cv2.cvtColor(imagem_colorida, cv2.COLOR_BGR2RGB): Converte a imagem da
representação de cores BGR para RGB, que é mais comumente usada em Python, e
armazena na variável imagem.
- np.ones((14, 14), np.uint8): Cria um kernel (ou máscara) de tamanho 14x14
preenchido com uns (1s) e tipo de dados uint8 (números inteiros sem sinal de 8 bits) e
armazena em kn. Este kernel é usado para operações de morfologia.
- cv2.morphologyEx(imagem, cv2.MORPH_CLOSE, kn): Realiza uma operação de
fechamento morfológico na imagem usando o kernel kn. O fechamento morfológico é
uma operação que suaviza contornos e fecha pequenos buracos em objetos.
- plt.subplots(ncols=2, figsize=(15, 5)): Cria uma figura com duas colunas para exibir
duas imagens lado a lado. Define o tamanho da figura como (15, 5).
- ax[0].imshow(imagem_colorida): Plota a imagem colorida original na primeira coluna
do subplot.
- ax[0].set_title('Imagem Colorida'): Define o título para a primeira imagem como
'Imagem Colorida'.
- ax[1].imshow(remocao_dos_objetos_pretos): Plota a imagem resultante após a
remoção dos objetos pretos na segunda coluna do subplot.
- ax[1].set_title('Remoção dos Objetos Pretos'): Define o título para a segunda imagem
como 'Remoção dos Objetos Pretos'.
- plt.show(): Exibe a figura com as duas imagens lado a lado.
Temos o seguinte resultado da imagem com preenchimento em todos os buracos
dos objetos pretos :
3.2 Utilizamos o seguinte código para remoção dos objetos pretos:

- cv2.imread(caminho_imagem, cv2.IMREAD_COLOR): Carrega uma imagem

colorida do caminho especificado e a armazena na variável imagem_colorida.
- cv2.cvtColor(imagem_colorida, cv2.COLOR_BGR2RGB): Converte a imagem da
representação de cores BGR para RGB, que é mais comumente usada em Python, e
armazena na variável imagem.
- np.ones((14, 14), np.uint8): Cria um kernel (ou máscara) de tamanho 14x14
preenchido com uns (1s) e tipo de dados uint8 (números inteiros sem sinal de 8 bits) e
armazena em kn. Este kernel é usado para operações de morfologia.
- cv2.morphologyEx(imagem, cv2.MORPH_CLOSE, kn): Realiza uma operação de
fechamento morfológico na imagem usando o kernel kn. O fechamento morfológico é
uma operação que suaviza contornos e fecha pequenos buracos em objetos.
- plt.subplots(ncols=2, figsize=(15, 5)): Cria uma figura com duas colunas para exibir
duas imagens lado a lado. Define o tamanho da figura como (15, 5).
- ax[0].imshow(imagem_colorida): Plota a imagem colorida original na primeira coluna
do subplot.
- ax[0].set_title('Imagem Colorida'): Define o título para a primeira imagem como
'Imagem Colorida'.
- ax[1].imshow(remocao_dos_objetos_pretos): Plota a imagem resultante após a
remoção dos objetos pretos na segunda coluna do subplot.
- ax[1].set_title('Remoção dos Objetos Pretos'): Define o título para a segunda imagem
como 'Remoção dos Objetos Pretos'.
- plt.show(): Exibe a figura com as duas imagens lado a lado.
Temos o seguinte resultado da imagem com a remoção dos objetos pretos :

3.4 Utilizamos o seguinte código para fazer o realce de borda:

- cv2.imread(caminho_imagem): Carrega uma imagem colorida do caminho

especificado e a armazena na variável imagem.
- cv2.cvtColor(imagem, cv2.COLOR_BGR2GRAY): Converte a imagem da
representação de cores BGR para escala de cinza (grayscale) e armazena na variável
imagem_gray.
- cv2.Canny(imagem_gray, 100, 200): Aplica o detector de bordas Canny à imagem em
escala de cinza. Os valores 100 e 200 são limiares que controlam a sensibilidade do
detector de bordas.
- cv2.imshow('Bordas Realçadas', bordas): Exibe a imagem resultante após a detecção
de bordas em uma janela com o título 'Bordas Realçadas'.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar a janela da imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.
Temos o seguinte resultado da imagem com o realce de borda:

4. Parte III
Na Parte III do trabalho, foram realizadas diferentes operações de processamento de
imagem nas imagens fornecidas. Na imagem "lena_ruido.png", foi aplicado o filtro da
Mediana para suavizar o ruído presente na imagem. Na imagem "coins.png", foram
aplicados os filtros Sobel e Prewitt para detecção de bordas e realce de características
importantes. Quanto à imagem "margaridas.png", um script foi desenvolvido para
dividir a imagem em quadrados distintos e aplicar um método de binarização em cada
uma dessas partes, permitindo assim uma análise mais detalhada das regiões individuais
da imagem. Essas operações visam melhorar a qualidade das imagens, destacar
características relevantes e facilitar a análise de padrões em cada imagem.
4.1 Utilizamos o seguinte código para aplicar o filtro da Mediana:

- cv2.imread(caminho_imagem): Carrega uma imagem do caminho especificado e a

armazena na variável imagem.
- cv2.medianBlur(imagem, 5): Aplica um filtro de mediana na imagem para suavizar o
ruído. O parâmetro 5 indica o tamanho da janela de filtragem. O filtro de mediana é
usado para reduzir o ruído preservando as bordas da imagem.
- cv2.imwrite('lena_ruido_filtro_mediana.jpg', imagem_suavizada): Salva a imagem
suavizada após a aplicação do filtro de mediana com o nome
'lena_ruido_filtro_mediana.jpg' no disco.
- cv2.imshow('Lena Filtro Mediana', imagem_suavizada): Exibe a imagem suavizada
em uma janela com o título 'Lena Filtro Mediana'.
- cv2.imshow('Imagem Original', imagem): Exibe a imagem original em uma janela
com o título 'Imagem Original'.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.
Temos o seguinte resultado da imagem com o filtro mediana:
4.2 Utilizamos o seguinte código para aplicar o filtro da Prewitt:

- cv2.imread('parte_III\Filtro_Prewitt\coins.png', cv2.IMREAD_GRAYSCALE):
Carrega uma imagem em tons de cinza (escala de cinza) do caminho especificado e a
armazena na variável imagem.
- np.array([...], dtype=np.float32): Define os kernels de filtro Prewitt para detecção de
bordas, tanto para a direção horizontal (kernel_x) quanto para a direção vertical
(kernel_y).
- cv2.filter2D(imagem, -1, kernel_x): Aplica o filtro Prewitt na direção horizontal à
imagem usando o kernel kernel_x e armazena o resultado em prewitt_x.
- cv2.filter2D(imagem, -1, kernel_y): Aplica o filtro Prewitt na direção vertical à
imagem usando o kernel kernel_y e armazena o resultado em prewitt_y.
- np.sqrt(prewitt_x2 + prewitt_y2): Calcula a magnitude das bordas detectadas
combinando as saídas dos filtros Prewitt horizontal e vertical. O resultado é armazenado
em magnitude.
- np.uint8(magnitude): Converte a magnitude em um array de inteiros sem sinal de 8
bits (uint8), que é o formato adequado para imagens.
- cv2.imwrite('coins_prewitt_x.jpg', prewitt_x): Salva a imagem das bordas detectadas
na direção horizontal como 'coins_prewitt_x.jpg'.
- cv2.imwrite('coins_prewitt_y.jpg', prewitt_y): Salva a imagem das bordas detectadas
na direção vertical como 'coins_prewitt_y.jpg'.
- cv2.imwrite('coins_magnitude.jpg', magnitude): Salva a imagem da magnitude das
bordas como 'coins_magnitude.jpg'.
- cv2.imshow('Imagem Original', imagem): Exibe a imagem original.
- cv2.imshow('Prewitt X', prewitt_x): Exibe a imagem das bordas detectadas na direção
horizontal.
- cv2.imshow('Prewitt Y', prewitt_y): Exibe a imagem das bordas detectadas na direção
vertical.
- cv2.imshow('Magnitude', magnitude): Exibe a imagem da magnitude das bordas.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.
Temos o seguinte resultado da imagem com o filtro prewitt:

Prewitt X e Prewitt Y
Imagem Original e Magnitude
4.2 Utilizamos o seguinte código para aplicar o filtro da Sobel:

- cv2.imread(caminho_imagem, cv2.IMREAD_GRAYSCALE): Carrega uma imagem

em escala de cinza (tons de cinza) do caminho especificado e armazena na variável
imagem.
- cv2.Sobel(imagem, cv2.CV_64F, 1, 0, ksize=5): Aplica o operador Sobel para
detecção de bordas no eixo X (horizontal) da imagem. Isso calcula as variações de
intensidade de cinza na direção horizontal.
- cv2.Sobel(imagem, cv2.CV_64F, 0, 1, ksize=5): Aplica o operador Sobel para
detecção de bordas no eixo Y (vertical) da imagem. Isso calcula as variações de
intensidade de cinza na direção vertical.
- np.sqrt(sobel_x2 + sobel_y2): Calcula a magnitude das bordas combinando os
resultados dos operadores Sobel no eixo X e Y usando o teorema de Pitágoras. Isso
resulta em uma imagem que destaca as bordas gerais da imagem.
- cv2.imshow('Imagem Original', imagem): Exibe a imagem original em escala de cinza
em uma janela com o título 'Imagem Original'.
- cv2.imshow('Sobel X', sobel_x): Exibe a imagem das bordas detectadas no eixo X
(horizontal) em uma janela com o título 'Sobel X'.
- cv2.imwrite('coins_sobel_x.jpg', sobel_x): Salva a imagem das bordas detectadas no
eixo X em um arquivo chamado 'coins_sobel_x.jpg'.
- cv2.imshow('Sobel Y', sobel_y): Exibe a imagem das bordas detectadas no eixo Y
(vertical) em uma janela com o título 'Sobel Y'.
- cv2.imwrite('coins_sobel_y.jpg', sobel_y): Salva a imagem das bordas detectadas no
eixo Y em um arquivo chamado 'coins_sobel_y.jpg'.
- cv2.imshow('Magnitude', magnitude): Exibe a imagem da magnitude das bordas em
uma janela com o título 'Magnitude'.
- cv2.imwrite('magnitude.jpg', magnitude): Salva a imagem da magnitude das bordas
em um arquivo chamado 'magnitude.jpg'.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.
Temos o seguinte resultado da imagem com o filtro Sobel:

Sobel X e Sobel Y
Imagem Origial e Magnitude

4.3 Utilizamos o seguinte código para aplicar a partição e binarização da imagem:

- cv2.imread(caminho_imagem, cv2.IMREAD_GRAYSCALE): Carrega uma imagem

em tons de cinza (escala de cinza) do caminho especificado e a armazena na variável
imagem.
- num_divisoes = 2: Define o número de divisões desejado para a imagem. Neste caso,
a imagem será dividida em 2x2 quadrados.
- altura, largura = imagem.shape: Obtém as dimensões (altura e largura) da imagem
carregada.
- quadrados_binarizados = []: Inicializa uma lista vazia chamada quadrados_binarizados
para armazenar os quadrados binarizados resultantes.
- tamanho_quadrado = min(altura, largura) // num_divisoes: Calcula o tamanho dos
quadrados com base no número de divisões desejado e nas dimensões da imagem.
- for y in range(0, altura, tamanho_quadrado): Loop que itera pelas coordenadas y dos
quadrados.
- for x in range(0, largura, tamanho_quadrado): Loop interno que itera pelas
coordenadas x dos quadrados.
- quadrado = imagem[y:y+tamanho_quadrado, x:x+tamanho_quadrado]: Seleciona um
quadrado da imagem com base nas coordenadas y e x.
- cv2.threshold(quadrado, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU):
Binariza o quadrado usando o método Otsu para determinar automaticamente um limite
de binarização. Os pixels acima do limite são definidos como 255 (branco) e os pixels
abaixo como 0 (preto). O quadrado binarizado é armazenado em quadrado_binarizado.
- quadrados_binarizados.append(quadrado_binarizado): Adiciona o quadrado
binarizado à lista de quadrados_binarizados.
- for i, quadrado_binarizado in enumerate(quadrados_binarizados): Itera pela lista de
quadrados binarizados.
- cv2.imshow(f'Quadrado {i}', quadrado_binarizado): Exibe cada quadrado binarizado
em uma janela com um título que indica seu número.
- cv2.waitKey(0): Aguarda indefinidamente até que uma tecla seja pressionada antes de
fechar as janelas de imagem.
- cv2.destroyAllWindows(): Fecha todas as janelas abertas pelo OpenCV após uma
tecla ser pressionada.

Temos o seguinte resultado da imagem após aplicar a partição e binarização da

imagem:
https://github.com/lucaasdias/processamentoImagem