Redução de Dimensionalidade em Imagens Usando Python

Introdução

Imagens digitais são representadas por combinações de pixels com valores RGB (Red, Green, Blue), o que as torna ricas em informações. No entanto, em muitas aplicações, como processamento de dados e redes neurais, não é necessário manter toda a riqueza de cores. Nesse contexto, a redução de dimensionalidade é essencial para simplificar e otimizar o uso das imagens.

Neste projeto, implementamos as seguintes transformações:

Conversão de uma imagem colorida para tons de cinza.
Binarização da imagem, reduzindo-a para apenas duas cores (preto e branco).

Todas as etapas foram implementadas manualmente, sem o uso de bibliotecas avançadas como OpenCV, para consolidar os conceitos fundamentais.

Etapas do Projeto

1. Carregando a Imagem

Para começar, utilizamos uma imagem colorida carregada diretamente do Google Drive em um ambiente Google Colab. Essa imagem serviu como base para as transformações subsequentes.

from PIL import Image

from google.colab import drive

drive.mount('/content/drive')
caminho_imagem = "/content/drive/My Drive/maltese-1123016_1280.jpg"
imagem_original = Image.open(caminho_imagem)

2. Conversão para Tons de Cinza

A conversão para tons de cinza reduz os três canais RGB para um único canal de intensidade, simplificando os dados da imagem. A fórmula usada foi:

Valor em Cinza=0.299×R+0.587×G+0.114×B\text{Valor em Cinza} = 0.299 \times R + 0.587 \times G + 0.114 \times BValor em Cinza=0.299×R+0.587×G+0.114×B

Cada pixel foi processado individualmente. Abaixo está a implementação:

def converter_para_cinza(imagem):

  largura, altura = imagem.size
  imagem_cinza = Image.new("L", (largura, altura))  # Escala de cinza

  for y in range(altura):
      for x in range(largura):
          r, g, b = imagem.getpixel((x, y))
          valor_cinza = int(0.299 * r + 0.587 * g + 0.114 * b)
          imagem_cinza.putpixel((x, y), valor_cinza)

  return imagem_cinza

3. Binarização (Preto e Branco)

Na binarização, os pixels são convertidos para apenas dois valores: preto (0) ou branco (255). A decisão é baseada em um limiar (threshold), que define o valor de corte:

Se o pixel for maior que o limiar, torna-se branco.
Caso contrário, torna-se preto.

A implementação é a seguinte:

def binarizar_imagem(imagem_cinza, limiar=127):
  largura, altura = imagem_cinza.size
  imagem_binaria = Image.new("1", (largura, altura))  # Binária

  for y in range(altura):
      for x in range(largura):
          valor_cinza = imagem_cinza.getpixel((x, y))
          valor_binario = 1 if valor_cinza > limiar else 0
          imagem_binaria.putpixel((x, y), valor_binario)

  return imagem_binaria

4. Exibição das Imagens

No Google Colab, utilizamos o método display da biblioteca IPython.display para exibir as imagens diretamente no notebook.

from IPython.display import display

# Converter a imagem para cinza
imagem_cinza = converter_para_cinza(imagem_original)

# Binarizar a imagem
imagem_binaria = binarizar_imagem(imagem_cinza)

# Exibir as imagens processadas
print("Imagem Original:")
display(imagem_original)

print("Imagem em Tons de Cinza:")
display(imagem_cinza)

print("Imagem Binarizada:")
display(imagem_binaria)

Resultados

A partir da imagem colorida original, geramos as seguintes transformações:

Imagem em Tons de Cinza: Reduzida para um único canal de intensidade (0-255).
Imagem Binarizada: Simplificada em apenas duas cores (0 e 255).

Imagens Geradas:

Imagem Original: Colorida, como carregada do Drive.
Imagem em Tons de Cinza: Processada com a fórmula matemática.
Imagem Binarizada: Resultado final em preto e branco.

Fonte: https://github.com/leticiafcarvalho/DesafioReducaoDimensionalidade/blob/main/Redu_o_de_Dimensionalidade_em_Imagens_para_Redes_Neurais.ipynb

Conclusão

Este projeto demonstrou como manipular imagens em Python, explorando diretamente os pixels sem o uso de bibliotecas avançadas. Ao implementar manualmente as transformações, foi possível compreender os fundamentos por trás da redução de dimensionalidade em imagens.

Essas técnicas são a base para aplicações mais complexas, como segmentação de imagens e pré-processamento para redes neurais.