[Portuguese] Uma implementação de uma técnica de quantização

This is the place to post any code that you want to share with the community. Only completed scripts should be posted here.

[Portuguese] Uma implementação de uma técnica de quantização

Postby isaacvm » Mon Dec 02, 2013 10:58 pm

Autores: Isaac V. M., Tulio M. M.
Disciplina - Semestre: Processamento Digital de Imagens - 2013/2
Prof.: Msc. Thiago Meireles Paixão
Instituição: Universidade Federal do Espírito Santo

Olá pessoal!

Na disciplina de Processamento Digital de Imagens(PDI) nós fizemos um trabalho sobre quantização de imagens. Resolvemos compartilhar o resultado deste trabalho aqui, para quem se interessar pelo o assunto e deseja ver uma solução alternativa para o problema.

O procedimento de quantização nada mais é que uma forma de discretizar valores contínuos em intervalos discretos. Ok, mas o que é isso na prática? No mundo real, existe um número infinito de variação de intensidade de pixels. Na computação, normalmente temos uma variação de 256 cores para cada canal da nossa imagem, o que implica que se tomarmos como exemplo imagens de 8 bits, conhecidas como imagens em escala de cinza, as infinitas intensidades de cor que existem do preto para o branco são discretizadas em 256 variações de cor. Da mesma forma que temos a imagem discretizada para 256 cores, podemos ter a mesma imagem discretizada para 2, 16, 32 ou para a quantidades de cores que acharmos interessante para nosso contexto de pesquisa. Por isso a quantização é um processamento interessante no estudo de PDI.

Agora, vamos ao que interessa. A implementação!

Nós usamos da biblioteca sys o argv para passar os argumentos do programa via shell, também usamos o numpy para manipularmos os arrays, importamos também o PyLab para gerarmos os gráficos, do matplotlib importamos cm para plotarmos a imagem mapeando-a com greys_r e assim em segmentos lineares.

O algoritmo começa com a atribuição do atributo nroCores que é responsável por definir a quantidade de cores que será quantizada na imagem. Após isso, importamos a imagem da Lena, foto disponível na biblioteca do Scipy, para o atributo orig. O atributo quantizada recebe um array, este array tem as dimensões da imagem da lena e é definido como um array com intervalo de valores de 0 a 255. Logo em seguida atribuimos o valor 0 para cada posição do nosso array definido como quantizada.

Code: Select all
from sys import argv
import numpy as np
import scipy.misc as msc
from PIL import Image
from pylab import *
import matplotlib.cm as cm

""" imagem e quantidade de cores para quantização que sãzo argumentos passados pelo shell """
script, nroCores = argv

""" numero de cores que será usada para a quantização """
ncores = int(nroCores)

""" imagem original da famosa lena """
orig = msc.lena()

""" ndarray com as dimensões da imagem original da nossa amiga lena, onde o 3º argumento do método
   zeros define o valor do ndarray como zero(0), uint8, para cada posicao """
quantizada = np.zeros([orig.shape[0], orig.shape[1]], dtype='uint8')


Trabalhando agora com os intervalos que usaremos na quantização, temos que definir o tamanho do passo do nosso algoritmo, ou seja, de quantos a quantos será o valor que vamos gerar. Para isso primeiro temos que definir o tamanho do passo, para isso, dividimos a quantidade de cores que temos originalmente na nossa imagem pela quantidade de cores que queremos no resultado do processo de quantização.

Code: Select all
""" define de quanto em quanto será os intervalos para a quantização da imagem """
passo = 256/ncores

""" define os intervalos de pixels que usaremos na analise """
intervalos = range(0,255+passo,passo)

""" define a média aritmetica de cada um dos intervalos que definimos """
mediaIntervalos = range(passo/2, 255+passo, passo)

""" cria um ndarray de mascaras para a imagem, onde o argumento ncores indica quantas camadas esta mascara ira ter
   e o tipo do ndarray é definido como booleano """
mascaras = np.empty([orig.shape[0], orig.shape[1], ncores], dtype=bool)

""" define todas as posições do ndarray como false """
mascaras[:,:,:] = False

""" pega o tempo atual(inicial) para calcular o tempo de execução da heurística """
startTime = datetime.now()

"""para cada uma das camadas do nosso ndarray de mascaras fazemos um "E lógico" que retorna se o pixel em questão
   está no intervalo analisado """
for x in range(ncores):
    mascaras[:,:,x] = np.logical_and((orig >= intervalos[x]), (orig < intervalos[x+1]))

"""para cada intervalo de cor do nosso ndarray, ele "pinta" os pixels que fazem correspondência com a máscara em questão"""
for i in range(ncores):
    quantizada[mascaras[:,:,i]] = mediaIntervalos[i]

"""
# pega o tempo atual(final) para calcular o tempo de execução da heurística
finalTime = datetime.now()

# calcula mse
mse = np.mean((quantizada - orig)**2)

print "MSE: " + str(mse)

# calcula o tempo de execucao
print "Tempo de Execucao: " + str(finalTime-startTime)
"""


Para plotar os resultados na tela do computador, dividimos a área da imagem em uma região superior e uma região inferior. Na região superior mostramos a imagem resultante do processo de quantização e na região inferior mostramos o histograma da imagem original e da imagem quantizada para efeito de comparação. A partir da análise do histograma podemos ver o nível de contraste das imagens e ainda realizar algumas mensurações estatísticas, tais como valores médios, máximos, ou desvio padrão nos níveis de cinza da imagem.

Code: Select all

""" inicializa a figura"""
figure(1)

"""divide a figura em 2 linhas e 1 coluna, alem disso, seleciona a parte superior
   2(linhas)1(coluna)1(parte superior)"""
subplot(211)

""" plota a imagem quantizada na parte selecionada """
imshow(quantizada, cmap = cm.Greys_r)

""" divide a figura em 2 linhas e 1 coluna, alem disso, seleciona a parte inferior
   2(linhas)1(coluna)2(parte inferior) """
subplot(212)

""" cria os histogramas das imagens quantizada e original, respectivamente em cada linha.
   Os argumentos são a imagem comprimida (pela função flatten(), e a quantidade de posições respectivamente """
hist(quantizada.flatten(), 256)
hist(orig.flatten(), 256)

""" exibe as imagens e o histograma destas imagens """
show()


Resultados obtidos

Abaixo temos o resultado da aplicação deste algoritmo de quantização aplicado para resultados com 2, 4, 8, 16, 32, 64, e 128 cores e seus respectivos histogramas comparando-os com a imagem original.

Image

Image

Image

Image

Image

Image

Image

Realizando uma inspeção visual, pode-se perceber que, pelo menos a olho nu, a diferença entre as imagens de 32 e 64 cores é pequena, já a diferença entre as imagens de 64 cores para 128 cores são praticamente imperceptíveis. Isso acontece devido ao fato de que o olho humano consegue distinguir muito mais variações de cores (milhares) do que as variações de cinza (aproximadamente 30).

Para uma análise numérica foi calculado o erro quadrático médio (EQM). Analisando o gráfico percebemos que a discrepância da imagem quantizada em relação à imagem original é maior quando a quantidade de cores é menor, o que é um comportamento natural, ao passo que, estamos substituindo um intervalo de cores por uma única cor que as representam. Quando aumentamos a quantidade de cores para realização do algoritmo de quantização, a substituição das cores se torna menos incorretas, pois se tem mais cores que são correspondentes à imagem original.

Image

Por fim, com o intuito de analisar o desempenho do algoritmo de acordo com a quantidade de cores processadas na quantização, geramos um gráfico do tempo de execução.

Image

Referências

http://astro.if.ufrgs.br/med/imagens/node27.htm
http://www.dpi.inpe.br/~carlos/Academicos/Cursos/Pdi/pdi_cores.html
PEDRINI, Hélio; SCHWARTZ, William Robson. Análise de imagens digitais: princípios, algoritmos e aplicações. São Paulo: Thomson Learning, 2008. xvi, 508 p. ISBN 9788522105953
isaacvm
 
Posts: 2
Joined: Mon Dec 02, 2013 10:21 pm

Re: [Portuguese] Uma implementação de uma técnica de quantiz

Postby stranac » Tue Dec 03, 2013 1:08 pm

That was a pretty interesting read.
Google translate really did a decent job with the translation(well, it did translate Portuguese as English, but w/e).

One thing that I really dislike about the code is your using (triple quoted) strings instead of comments.
Please don't do that...
Friendship is magic!

R.I.P. Tracy M. You will be missed.
User avatar
stranac
 
Posts: 1246
Joined: Thu Feb 07, 2013 3:42 pm

Re: [Portuguese] Uma implementação de uma técnica de quantiz

Postby isaacvm » Wed Dec 04, 2013 3:39 am

thanks for reply! I'll be careful about comments at next time! Promise! :D
isaacvm
 
Posts: 2
Joined: Mon Dec 02, 2013 10:21 pm


Return to Completed Scripts

Who is online

Users browsing this forum: No registered users and 1 guest

cron