daniel_chiu_Ex2

Autor: daniel_chiu
Data: 18/03/2009

Neste exercício, vou implementar duas funções da toolbox_ia636 utilizando meshgrid e comparar as funções implementadas às da toolbox.

Rampa

Essa imagem consiste de uma ou mais bandas verticais em escala de cinza.

A equação para a rampa é a seguinte:

Onde:
  • n é o número de bandas
  • W é a largura da imagem
  • k_max é o valor máximo em escala de cinza
  • k_min é o valor mínimo em escala de cinza

Abaixo se apresenta o código da execução da função iaramp da toolbox. Será impressa uma imagem 800x600 com 16 faixas monocromáticas de 0 a 255.

1 t1=time.time() # Tempo inicial de execução
2 w,h=800,600
3 n=16
4 k_min,k_max=0,255
5 IA_RAMP=iaramp([h,w], n, [k_min,k_max])
6 t2=time.time() # Tempo final de execução
7 mmshow(uint16(IA_RAMP), title='Tempo de execução iaramp = '+str(t2-t1)+'s')

Tempo de execução iaramp = 0.0461127758026s

A implementação utilizando o meshgrid se dá da seguinte maneira:

 1 #Função meshgrid_ramp
 2 #Entradas:
 3 #    s - array que dá a altura e a largura da imagem - [H W]
 4 #    n - número de bandas da imagem rampa
 5 #    o - array que fornece a faixa de valores de tons de cinza que comporão
 6 #        a imagem - [K_MIN K_MAX]
 7 
 8 def meshgrid_ramp(s, n, o):
 9     s[0],s[1]=h,w
10     o[0],o[1]=k_min,k_max
11 
12     # meshgrid para criar arrays de índices
13     X,Y=meshgrid(range(0,w), range(0,h))
14 
15     # função da imagem rampa
16     G=floor((floor(n*X/w)*(k_max-k_min))/(n-1))+k_min
17     return G
18 
19 t1=time.time() # Tempo inicial de execução
20 w,h=800,600
21 n=16
22 k_min,k_max=0,255
23 MG_RAMP=meshgrid_ramp([h,w], n, [k_min,k_max])
24 t2=time.time() # Tempo final de execução
25 mmshow(uint16(MG_RAMP), title='Tempo de execução meshgrid_ramp = '+str(t2-t1)+'s')

Tempo de execução meshgrid_ramp = 0.0464019775391s

Percebe-se que o desempenho da função implementada é bem próximo o da função da toolbox, às vezes, ligeiramente inferior e, às vezes, ligeiramente superior.

Círculo

Esta imagem consiste de um círculo branco em um fundo preto.

A equação do círculo é a seguinte:

Onde:
  • (x0, y0) são as coordenadas do centro do círculo (em relação ao ponto mais acima e à esquerda da imagem)
  • r é o raio do círculo

Geraremos um retângulo de dimensões 800x600, com um círculo no centro da figura.

Abaixo está a execução da função da toolbox iacircle.

1 t1=time.time()
2 w,h=800,600
3 r=150
4 x0,y0=400,300 # centro da figura
5 IA_CIRCLE=iacircle([h,w],r,[y0,x0])
6 t2=time.time()
7 mmshow(uint16(IA_CIRCLE), title='Tempo de execução iacircle = '+str(t2-t1)+'s')

Tempo de execução iacircle = 0.0256888866425s

A seguir, temos a implementação da função utilizando o meshgrid.

 1 def meshgrid_circle(s, r, c):
 2     s=[h,w]    # dimensões do círculo
 3     c=[y0,x0]  # centro do círculo
 4 
 5     X,Y=meshgrid(range(0,w), range(0,h)) # criação dos arrays de índices
 6     G=((X-x0)**2+(Y-y0)**2<=r**2) # aplicação da equação do círculo
 7 
 8     # Note que o array G é um array de elementos booleanos.
 9     # Na hora de converter para uint16, estes elementos se tornarão zeros ou uns.
10 
11     return G
12 
13 t1=time.time()
14 w,h=800,600
15 r=150
16 x0,y0=400,300 # centro da figura
17 MG_CIRCLE=meshgrid_circle([h,w],r,[y0,x0])
18 t2=time.time()
19 mmshow(uint16(MG_CIRCLE), title='Tempo de execução meshgrid_circle = '+str(t2-t1)+'s')

Tempo de execução meshgrid_circle = 0.0224540233612s

A função implementada pelo meshgrid apresentou um desempenho melhor que a função da toolbox, como podemos ver nas figuras acima.