daniel_chiu_Ex3

Autor: daniel_chiu
Data: 23/03/2009

Item 1

Item 2

Item 1

A função xadrez utilizada é baseada na implementação utilizando ladrilhos. Ela foi adaptada para que se possa aplicar tons de cinza e tamanhos variáveis para os mosaicos. Os tons padrão para esta função são preto (tom índice 0) e branco (tom índice 255).

 1 def chess_tile(h, w, tile_h, tile_w, color1=0, color2=255, print_img=True):
 2 
 3     BASE1=hstack((color1*ones((tile_h,tile_w)),color2*ones((tile_h,tile_w))))  #array-base para utilização da função tile
 4     BASE2=hstack((color2*ones((tile_h,tile_w)),color1*ones((tile_h,tile_w))))
 5     BASE=vstack((BASE1,BASE2))
 6 
 7     #preenche-se o array além do tamanho da imagem desejada,
 8     #pois como o array-base possui dimensões de tamanho par,
 9     #deve-se contornar a situação de gerar array com dimensões
10     #de tamanho ímpar.
11     A=tile(BASE,(h/(2*tile_h)+1,w/(2*tile_w)+1))
12 
13     #realiza-se o slicing desse array, obtendo a matriz desejada
14     A=A[0:h,0:w]
15 
16     if(print_img):
17         adshow(uint16(A), title = 'N='+str(h/tile_h)+' M='+str(w/tile_w)+' L='+str(tile_h)+', tons níveis '+str(color1)+' e '+str(color2) )
18     return A

Para a primeira parte do exercício, será gerada uma imagem 200x200, com 100x100 mosaicos de 2x2. O mosaico será composto de tons em nível 0 (preto) e 255 (branco).

1 # o mosaico será composto de quadrados pretos e brancos como padrão
2 chess_tile(200,200,2,2)

N=100 M=100 L=2, tons níveis 0 e 255

A próxima imagem tem quadrados de tons de índices 120 e 121. Não é nítida a diferença dos tons dentro do mosaico.

1 chess_tile(200,200,2,2,120,121)

N=100 M=100 L=2, tons níveis 120 e 121

Aumenta-se o índice da cor mais clara e, observamos o efeito do distanciamento entre as cores de cada quadrado do mosaico.

1 for i in range(1,11):
2     chess_tile(200,200,2,2,120,120+i)

N=100 M=100 L=2, tons níveis 120 e 121

N=100 M=100 L=2, tons níveis 120 e 122

N=100 M=100 L=2, tons níveis 120 e 123

N=100 M=100 L=2, tons níveis 120 e 124

N=100 M=100 L=2, tons níveis 120 e 125

N=100 M=100 L=2, tons níveis 120 e 126

N=100 M=100 L=2, tons níveis 120 e 127

N=100 M=100 L=2, tons níveis 120 e 128

N=100 M=100 L=2, tons níveis 120 e 129

N=100 M=100 L=2, tons níveis 120 e 130

Nesse ponto, o contraste começa a ser perceptível aos olhos quando os níveis têm diferença de 5.

Quanto maior o valor de L, mais fácil pode-se perceber o contraste entre os quadrados do xadrez, como nas figuras abaixo, em que se utilizou L igual a 4, 8, 10 e 25. Foram utilizados tons próximos ao 120, alterando-se apenas a diferença entre o tom mais claro e mais escuro.

1 for i in range(4,0,-1):
2     chess_tile(200,200,4,4,120,120+i)
3     chess_tile(200,200,8,8,120,120+i)
4     chess_tile(200,200,10,10,120,120+i)
5     chess_tile(200,200,25,25,120,120+i)

N=50 M=50 L=4, tons níveis 120 e 124

N=25 M=25 L=8, tons níveis 120 e 124

N=20 M=20 L=10, tons níveis 120 e 124

N=8 M=8 L=25, tons níveis 120 e 124

N=50 M=50 L=4, tons níveis 120 e 123

N=25 M=25 L=8, tons níveis 120 e 123

N=20 M=20 L=10, tons níveis 120 e 123

N=8 M=8 L=25, tons níveis 120 e 123

N=50 M=50 L=4, tons níveis 120 e 122

N=25 M=25 L=8, tons níveis 120 e 122

N=20 M=20 L=10, tons níveis 120 e 122

N=8 M=8 L=25, tons níveis 120 e 122

N=50 M=50 L=4, tons níveis 120 e 121

N=25 M=25 L=8, tons níveis 120 e 121

N=20 M=20 L=10, tons níveis 120 e 121

N=8 M=8 L=25, tons níveis 120 e 121

Nos últimos quatro quadrados(tons 120 e 121), é pouco perceptível a distinção entre os tons no xadrez, mesmo quando L=10 ou L=25. Distingue-se mais facilmente os casos L=8 e L=10 do que os casos L=4 e L=25

Item 2

Neste item, vai-se comparar os efeitos de modificações na resolução espacial e em níveis de cinza.

Escala de cinza

Abaixo, está a função reduce_grayscale_depth() que, dada a imagem e o índice, reduz o número de níveis de cinza relativo ao índice fornecido. A equação para reduzir o nível de cinza de um píxel é:

Onde:
  • p_R é o píxel resultante da redução de escala
  • p_O é o píxel original
  • r é o fator de redução
  • n é o níveis de cinza, determinada pelo fator de redução
1 def reduce_grayscale_depth(IMAGE, ratio):
2 
3     n=256/ratio # número de níveis de cinza, dado o fator de redução
4     NEW_IMAGE = floor(IMAGE/ratio)*floor(255/(n-1)) # nova imagem utilizando o fator de redução
5     NEW_IMAGE = NEW_IMAGE.astype(uint16)
6     return NEW_IMAGE

A imagem terá os seus níveis de cinza reduzidos em 2 a 128 vezes.

1 ORIGINAL_IMG=mmreadgray('MVBook/jangada.png')
2 adshow(ORIGINAL_IMG, title='Imagem original com 256 níveis de cinza')
3 for i in range(1,8):
4     DOWNSCALED_IMG=reduce_grayscale_depth(ORIGINAL_IMG, 2**i)
5     adshow(DOWNSCALED_IMG, title='Fator de redução '+str(2**i)+' em níveis de cinza')

Imagem original com 256 níveis de cinza

Fator de redução 2 em níveis de cinza

Fator de redução 4 em níveis de cinza

Fator de redução 8 em níveis de cinza

Fator de redução 16 em níveis de cinza

Fator de redução 32 em níveis de cinza

Fator de redução 64 em níveis de cinza

Fator de redução 128 em níveis de cinza

Nota-se o distanciamento entre os níveis de cinza dos píxeis a partir do fator 4. Com fator 2, esta perda de resolução não é sentida. Esse distanciamento entre os níveis de cinza leva a uma homogeneização dos níveis intermediários de cinza da imagem original.

Resolução espacial

Para este exercício, o tamanho da imagem será reduzida e, em seguida, ampliada para demonstrar os efeitos da diminuição da resolução espacial, simulando a diminuição do número de sensores de captura da imagem.

 1 # Função para reduzir o tamanho da imagem
 2 def reduce_img(IMAGE, ratio):
 3 
 4     old_h,old_w=IMAGE.shape
 5 
 6     new_h=old_h/ratio
 7     new_w=old_w/ratio
 8 
 9     X,Y=meshgrid(arange(0,new_w), arange(0,new_h))
10 
11     NEW_IMAGE=IMAGE[Y*ratio,X*ratio]
12 
13     return NEW_IMAGE
14 
15 
16 # Função para aumentar o tamanho da imagem
17 def enlarge_img(IMAGE, ratio):
18 
19     old_h,old_w=IMAGE.shape
20 
21     new_h=old_h*ratio
22     new_w=old_w*ratio
23 
24     X,Y=meshgrid(arange(0,new_w), arange(0,new_h))
25 
26     NEW_IMAGE=IMAGE[Y/ratio,X/ratio]
27 
28     return NEW_IMAGE

Abaixo encontram-se as imagens reduzidas por fatores de 2, 4, 8, 16 e 32.

1 adshow(ORIGINAL_IMG, title='Imagem original')

Imagem original

1 for i in range(1,6):
2     DOWNSIZED_IMG=reduce_img(ORIGINAL_IMG, 2**i)
3     adshow(DOWNSIZED_IMG, title='Fator='+str(2**i)+' - imagem reduzida')
4     BIG_DOWNSIZED_IMG=enlarge_img(DOWNSIZED_IMG, 2**i)
5     adshow(BIG_DOWNSIZED_IMG, title='Fator='+str(2**i)+' - tamanho original')

Fator=2 - imagem reduzida

Fator=2 - tamanho original

Fator=4 - imagem reduzida

Fator=4 - tamanho original

Fator=8 - imagem reduzida

Fator=8 - tamanho original

Fator=16 - imagem reduzida

Fator=16 - tamanho original

Fator=32 - imagem reduzida

Fator=32 - tamanho original

Percebe-se que, quanto menor o número de sensores, ao ampliar a imagem, ela fica mais pixelada, ou seja, menos nítida. Isso deve-se ao fato de que ao ampliar as imagens reduzidas ao seu tamanho original, os píxeis delas são replicados.