image

Acesse bootcamps ilimitados e +650 cursos

50
%OFF

LG

Letícia Greve25/11/2024 11:01
Compartilhe

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:

    1. Conversão de uma imagem colorida para tons de cinza.
    2. 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:

    1. Imagem em Tons de Cinza: Reduzida para um único canal de intensidade (0-255).
    2. 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.

    image

    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.

    Compartilhe
    Comentários (1)

    VS

    Valdenor Sá - 25/11/2024 11:07

    Top