Evento 24/09/22 – Pillow e Mineração de Dados

No dia 24/09/22, a comunidade realizou mais um encontro para falarmos sobre a bilbioteca Pillow para manipulação e tratamento de imagens, apresentado por Altair Ribeiro.

Também, foi apresentado a Mineração de Dados na teoria e na prática e, um Caso de Uso demonstrando a ingestão, tratamento e processamento de dados, por José Fontebasso Neto.

O evento aconteceu na Unisantos, no campus Dom Idilio.

Arquivos para Download

  • Arquivo do notebook para o Jupyter Notebook.

Baixe aqui: Arquivo com o notebook (Jupyter Notebook) - Uso da biblioteca PILLOW (553 downloads )

  • Arquivo da Imagem utilizada no notebook.

Baixe aqui: Imagem exemplo utilizado no notebook (Crédito: Foto de David Clode no Unsplash) (554 downloads )

Imagens do Evento

José Fontebasso Neto
Participantes da comunidade
José Fontebasso Neto
José Fontebasso Neto
Participantes da comunidade
Participantes da comunidade
Participantes da comunidade
Participantes da comunidade

Notebook

Pillow_light

Biblioteca Pillow

Chamada de PIL (Python Imaging Library) é uma bilbioteca para o processamento de imagens na linguagem Python. Ela suporta vários formatos de imagens e entre eles estão: BMP, GIF, ICO, JPEG, PNG e TIFF.

Documentação da Pillow

https://pillow.readthedocs.io

Importar a Biblioteca PIL

In [1]:
# Importar a biblioteca
from PIL import Image
import ipywidgets as widgets
import IPython.display as display
import matplotlib.pyplot as plt
%matplotlib inline

Carregar uma imagem

Crédito: Foto de David Clode no Unsplash

In [2]:
# Carregar a imagem
img = Image.open("peixe.jpg")

Mostrar a imagem no tamanho natural

In [3]:
# Mostrar a imagem local
img
Out[3]:

Mostrar a imagem no aplicativo padrão

In [4]:
# Mostrar a imagem no aplicativo padrão
img.show()

Identificar o tipo de imagem

In [5]:
# Tipo da Imagem
print(img.mode)

RGB

Identificar o formato da imagem

In [6]:
# Formato da Imagem
print("Formato = ", img.format)

Formato =  JPEG

Identificar o tamanho da imagem em pixels

In [7]:
# Tamanho da Imagem
print(img.size)

(810, 540)

O Tamanho melhor apresentado

In [8]:
# De novo o tamanho da Imagem com um texto melhor
print("Tamanho = ", img.size)

Tamanho =  (810, 540)

Melhorando a apresentação do tamanho

In [9]:
# De novo o tamanho da Imagem com um texto muito melhor
print("Lagura = ", img.size[0])
print("Altura = ", img.size[1])
print("Imagem possui = ", img.size[0], " x ", img.size[1], " pixels")

Lagura =  810
Altura =  540
Imagem possui =  810  x  540  pixels

Rotacionando a imagem

In [10]:
# Rotacionando uma imagem
grau = int(input("Quantos graus para rotacionar a imagem ?"))
rota_img = img.rotate(grau)
rota_img

Quantos graus para rotacionar a imagem ?45
Out[10]:

Redimensionar a imagem

In [11]:
# Redimensionar a imagem
print("Imagem possui = ", img.size[0], " x ", img.size[1], " pixels")
largura = int(input("Qual a nova largura da imagem ?"))
altura =  int(input("Qual a nova altura da imagem ?"))
tamanho_novo = (largura, altura)
resize_img = img.resize(tamanho_novo)

if largura == 1000:
    if altura == 100:
        print()
        print("Virou uma manjuba !!!!!!!!")
        print("Imagem possui = ", largura, " x ", altura, " pixels")
resize_img

Imagem possui =  810  x  540  pixels
Qual a nova largura da imagem ?1000
Qual a nova altura da imagem ?100

Virou uma manjuba !!!!!!!!
Imagem possui =  1000  x  100  pixels
Out[11]:

Alterando o tamanho da imagem

In [12]:
# Gravando a manjuba
tamanho = (1000, 100)
img = Image.open("peixe.jpg")
manjuba = img.resize(tamanho, resample = Image.BILINEAR)

manjuba.save("manjuba.jpg")

Abrindo a foto da manjuba

In [13]:
# Abrir a foto da manjuba
img1 = Image.open("manjuba.jpg")
print("Novo tamanho agora como manjuba = ", img1.size[0], " x ", img1.size[1], " pixels")
img1

Novo tamanho agora como manjuba =  1000  x  100  pixels
Out[13]:

Transformando o arquivo

In [14]:
### Carregar de novo a imagem
img = Image.open("peixe.jpg")
tamanho_novo = (480, 320)
img = img.resize(tamanho_novo)
img
Out[14]:

Retirar a luminosidade da imagem

In [15]:
# Retirar a iluminação da imagem

#tamanho_novo = (480, 320)
#img = img.resize(tamanho_novo)
with img as imgnova:
    img1 = img.convert("L") #Luminancia
img1
Out[15]:
In [16]:
# Crie um filtro de classificação.
# O filtro de classificação classifica todos os pixels em uma janela de determinado tamanho e retorna o valor de classificação.
from PIL import ImageFilter

# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Aplicar o filtro de Classificação
out = img.filter(ImageFilter.RankFilter(size=15, rank=3))

# Gravar um arquivo de saída
out.save("out.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [17]:
# Crie um filtro mínimo. Escolhe o valor de pixel mais baixo em uma janela com o tamanho fornecido.
from PIL import ImageFilter
out1 = img.filter(ImageFilter.MinFilter(size=5))

# Gravar um arquivo de saída
out1.save("out1.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out1.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [18]:
# Crie um filtro de modo. Escolhe o valor de pixel mais frequente em uma imagem delimitada com o tamanho fornecido.
# Os valores de pixel que ocorrem apenas uma ou duas vezes são ignorados;
# se nenhum valor de pixel ocorrer mais de duas vezes, o valor de pixel original será preservado.
out2 = img.filter(ImageFilter.ModeFilter(size=15))

# Gravar um arquivo de saída
out2.save("out2.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out2.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [19]:
# Filtro para borrar imagem borrada
from PIL import ImageFilter

out3 = img.filter(ImageFilter.BLUR)

# Gravar um arquivo de saída
out3.save("out3.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out3.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=400, height=300)
wi2 = widgets.Image(value=img2, format='jpg', width=400, height=300)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [20]:
# Filtro para contorno
from PIL import ImageFilter

out4 = img.filter(ImageFilter.CONTOUR)

# Gravar um arquivo de saída
out4.save("out4.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out4.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [21]:
# Filtro para EDGE Enhance
from PIL import ImageFilter

out5 = img.filter(ImageFilter.EDGE_ENHANCE)


# Gravar um arquivo de saída
out5.save("out5.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out5.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [22]:
# Filtro para EDGE Enhance More
from PIL import ImageFilter

out6 = img.filter(ImageFilter.EDGE_ENHANCE_MORE)

# Gravar um arquivo de saída
out6.save("out6.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out6.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [23]:
# Filtro para Emboss
from PIL import ImageFilter

out7 = img.filter(ImageFilter.EMBOSS)

# Gravar um arquivo de saída
out7.save("out7.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out7.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [24]:
# Filtro para Find Edges
from PIL import ImageFilter

out8 = img.filter(ImageFilter.FIND_EDGES)

# Gravar um arquivo de saída
out8.save("out8.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out8.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [25]:
# Filtro para SHARPEN. Utilizado para Nitidez.
from PIL import ImageFilter

out9 = img.filter(ImageFilter.SHARPEN)

# Gravar um arquivo de saída
out9.save("out9.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out9.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [26]:
# Filtro para SMOOTH. Para suavizar a imagem.
from PIL import ImageFilter

out10 = img.filter(ImageFilter.SMOOTH)

# Gravar um arquivo de saída
out10.save("out10.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out10.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [29]:
# Filtro para BoxBlur. Utilizado para desfoque de imagens.
from PIL import ImageFilter

out11 = img.filter(ImageFilter.BoxBlur(10))

# Gravar um arquivo de saída
out11.save("out11.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out11.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [30]:
# Filtro para GaussianBlur. É um filtro para desfoque utilizando uma função gaussiana.
from PIL import ImageFilter

out12 = img.filter(ImageFilter.GaussianBlur(radius=5))

# Gravar um arquivo de saída
out12.save("out12.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out12.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [31]:
# Filtro para Unsharp Masking
# Aplica um desfoque gaussiano a uma cópia da imagem original e a compara com o original.
# Se a diferença for maior do que uma configuração de limite especificada pelo usuário, as imagens serão (de fato) subtraídas.
# O Unsharp Masking de nitidez é uma maneira flexível e poderosa de aumentar a nitidez da imagem.
import matplotlib.pyplot as plt 
out13 = img.filter(ImageFilter.UnsharpMask(radius=20, percent=500, threshold=3))

# Gravar um arquivo de saída
out13.save("out13.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out13.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=400, height=300)
wi2 = widgets.Image(value=img2, format='jpg', width=400, height=300)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

Mostrando a imagem com os eixos de tamanho em pixels

In [32]:
# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Plotar a imagem com os eixos
plt.imshow(img)
Out[32]:
<matplotlib.image.AxesImage at 0x1c596f3c588>

Cortando uma parte da imagem

In [33]:
# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Cortar a cabeça do peixe
cropimg = img.crop((500, 100, 700, 400)) 
cropimg
Out[33]:

Colocando título, tirando o eixo e mostrando a imagem

In [34]:
# Manipulando a plotagem da imagem
plt.figure(figsize=(7, 7))
plt.title("Eu quero ser a Dory!!!!")
plt.imshow(img)
plt.axis('off')
plt.show()

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *