Introdução
A quantização de cores é um processo de redução do número de cores distintas usadas numa imagem, preservando a sua aparência geral. Isto é feito agrupando cores semelhantes e representando-as com um único valor de cor. Neste laboratório, utilizaremos o algoritmo K-Means para realizar a quantização de cores numa imagem do Palácio de Verão na China.
Dicas da Máquina Virtual
Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.
Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.
Se tiver problemas durante a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.
Carregar e Exibir a Imagem Original
Começaremos carregando e exibindo a imagem original do Palácio de Verão.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_sample_image
## Carregar a foto do Palácio de Verão
china = load_sample_image("china.jpg")
## Exibir a imagem original
plt.figure()
plt.axis("off")
plt.title("Imagem Original")
plt.imshow(china)
plt.show()
Converter a Imagem para Floats e Reformate
Vamos converter a imagem para floats e reformá-la num array numpy 2D para que possa ser processada pelo algoritmo K-Means.
## Converter para floats em vez da codificação inteira de 8 bits padrão.
china = np.array(china, dtype=np.float64) / 255
## Obter as dimensões da imagem
w, h, d = original_shape = tuple(china.shape)
assert d == 3
## Reformate a imagem num array numpy 2D
image_array = np.reshape(china, (w * h, d))
Ajustar o Modelo K-Means
Ajustaremos o modelo K-Means a uma pequena amostra dos dados da imagem e usá-lo-emos para prever os índices de cores na imagem completa.
from sklearn.cluster import KMeans
from sklearn.utils import shuffle
from time import time
n_colors = 64
## Ajustar o modelo K-Means a uma pequena amostra dos dados
print("Ajustando o modelo a uma pequena amostra dos dados")
t0 = time()
image_array_sample = shuffle(image_array, random_state=0, n_samples=1000)
kmeans = KMeans(n_clusters=n_colors, n_init="auto", random_state=0).fit(
image_array_sample
)
print(f"feito em {time() - t0:0.3f}s.")
## Obter rótulos para todos os pontos
print("Prevendo índices de cores na imagem completa (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
print(f"feito em {time() - t0:0.3f}s.")
Prever Índices de Cores Usando um Livro de Códigos Aleatório
Preveremos os índices de cores na imagem completa usando um livro de códigos aleatório.
## Obter um livro de códigos aleatório
codebook_random = shuffle(image_array, random_state=0, n_samples=n_colors)
## Prever índices de cores na imagem completa usando o livro de códigos aleatório
print("Prevendo índices de cores na imagem completa (aleatório)")
t0 = time()
labels_random = pairwise_distances_argmin(codebook_random, image_array, axis=0)
print(f"feito em {time() - t0:0.3f}s.")
Recriar a Imagem
Recriaremos a imagem comprimida usando o livro de códigos e as etiquetas obtidas do modelo K-Means e do livro de códigos aleatório.
def recreate_image(codebook, labels, w, h):
"""Recriar a imagem (comprimida) a partir do livro de códigos e etiquetas"""
return codebook[labels].reshape(w, h, -1)
## Exibir a imagem original juntamente com as imagens quantizadas
plt.figure()
plt.clf()
plt.axis("off")
plt.title("Imagem original (96.615 cores)")
plt.imshow(china)
plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Imagem quantizada ({n_colors} cores, K-Means)")
plt.imshow(recreate_image(kmeans.cluster_centers_, labels, w, h))
plt.figure()
plt.clf()
plt.axis("off")
plt.title(f"Imagem quantizada ({n_colors} cores, Aleatório)")
plt.imshow(recreate_image(codebook_random, labels_random, w, h))
plt.show()
Resumo
Neste laboratório, aprendemos como usar o algoritmo de agrupamento K-Means para realizar quantização de cores numa imagem. Carregámos e exibimos a imagem original, convertendo-a para valores em ponto flutuante e remodelando-a num array numpy 2D. Ajustámos o modelo K-Means a uma subamostra dos dados da imagem e utilizámo-lo para prever os índices de cores na imagem completa. Também previmos os índices de cores na imagem completa usando um livro de códigos aleatório. Finalmente, recriámos a imagem comprimida usando o livro de códigos e as etiquetas obtidas do modelo K-Means e do livro de códigos aleatório, exibindo a imagem original juntamente com as imagens quantizadas.