Gustavo Kaneblai - Exercicio 2 (Funcoes da lib IA636)

Implementar a funcao iacircle:

iacircle

g = iacircle( s, r, c)

Esta funcao e' usada para gerar circulos binarios.

1.Primeiro verificamos os parametros da funcao.

s = as dimencoes da imagem [altura, largura]

r = raio do circulo

c = posicao do centro do circulo [posicao_no_eixo_y, posicao_no_eixo_z)

g = imagem resultante

2.Testamos a funcao executando o seguinte codigo:

 1 largura = 300
 2 altura = 200
 3 raio = 30
 4 posicao_x = 150
 5 posicao_y = 100
 6 
 7 t_inicial = time.time()
 8 F = iacircle([altura ,largura ], raio , [posicao_y, posicao_x])
 9 tempo_iacircle = time.time() - t_inicial
10 
11 titulo = "iacircle() - tempo = %f" %tempo_iacircle
12 mmshow(uint16(F), title = titulo )
13 
14 t_inicial = time.time()
15 F = iacircle([altura ,largura ], raio , [posicao_y, posicao_x])
16 tempo_iacircle = time.time() - t_inicial
17 
18 titulo = "iacircle() APOS LOAD DAS BIBLIOTECAS - tempo = %f" %tempo_iacircle
19 mmshow(uint16(F), title = titulo )

iacircle() - tempo = 0.002613

iacircle() APOS LOAD DAS BIBLIOTECAS - tempo = 0.002093

Note que a segunda chamada da funcao e executada em menor tempo devido a carga das bibliotecas ja terem sido realizadas pela chamada anterior.

3.Para criar nossa implementacao, consideramos a equacao que descreve o circulo como sendo:

  1. Faremos uma versao inicial simples, usando "for" varrendo x e y e verificando se coloca uns ou zero na matriz imagem
 1 # Implementando a funcao iacircle
 2 
 3 def kcircle_usando_for(largura_da_imagem, altura_da_imagem, raio_do_circulo, centro_do_circulo_no_eixo_x, centro_do_circulo_no_eixo_y):
 4 
 5     matriz_da_imagem = zeros((altura_da_imagem, largura_da_imagem))
 6     yc = centro_do_circulo_no_eixo_y
 7     xc = centro_do_circulo_no_eixo_x
 8     r2 =  raio_do_circulo**2
 9 
10     for x in range(0, largura_da_imagem):
11         for y in range(0, altura_da_imagem):
12             if (((x - xc)**2)+ ((y - yc)**2)) <= (r2):
13                 matriz_da_imagem[y,x] = 1
14 
15     return matriz_da_imagem
16 # def kcircle_usando_for
17 
18 
19 # Chamando a funcao:
20 
21 t_inicial = time.time()
22 F = kcircle_usando_for(largura, altura, raio , posicao_x, posicao_y)
23 tempo_kcircle_usando_for = time.time() - t_inicial
24 
25 titulo = " kcircle_usando_for() - tempo = %f" %tempo_kcircle_usando_for
26 mmshow(uint16(F), title = titulo )
27 
28 
29 t_inicial = time.time()
30 F = kcircle_usando_for(largura, altura, raio , posicao_x, posicao_y)
31 tempo_kcircle_usando_for = time.time() - t_inicial
32 
33 titulo = " kcircle_usando_for() APOS LOAD DAS BIBLIOTECAS - tempo = %f" %tempo_kcircle_usando_for
34 mmshow(uint16(F), title = titulo )
35 
36 delta_tempo = tempo_kcircle_usando_for - tempo_iacircle
37 print "kcircle_usando_for() em relacao a iacircle():"
38 print "Tempo de execucao iacircle() = %f" %tempo_iacircle
39 print "Tempo de execucao kcircle_usando_for() = %f" %tempo_kcircle_usando_for
40 print "Tempo kcircle_usando_for() - iacircle() = %f" %delta_tempo
kcircle_usando_for() em relacao a iacircle():
Tempo de execucao iacircle() = 0.002093
Tempo de execucao kcircle_usando_for() = 0.024788
Tempo kcircle_usando_for() - iacircle() = 0.022695

kcircle_usando_for() - tempo = 0.020811

kcircle_usando_for() APOS LOAD DAS BIBLIOTECAS - tempo = 0.024788

Note que a assinatura da funcao foi mudada para ficar mais amigavel. Tambem percebemos que esta funcao e' aproximadamente 10x mais lenta que a iacircle().

5. Agora faremos uma versao usando matriz. - Criando 2 matrizes, uma com os valores das linhas e outra com os valores das colunas. - Aplica-se a equacao do circulo nas matrizes, uma vez que uma matriz tem os valores "X" e outra os valores "Y"

 1 def kcircle(largura_da_imagem, altura_da_imagem, raio_do_circulo, centro_do_circulo_no_eixo_x, centro_do_circulo_no_eixo_y):
 2 
 3     yc = centro_do_circulo_no_eixo_y
 4     xc = centro_do_circulo_no_eixo_x
 5     r2 =  raio_do_circulo**2
 6 
 7     matriz_y, matriz_x = mgrid[0:altura_da_imagem, 0:largura_da_imagem]
 8 
 9     matriz_da_imagem =  (((matriz_x - xc)**2) + ((matriz_y - yc)**2) <= r2)
10 
11     return matriz_da_imagem
12 # def kcircle
13 
14 # Chamando a funcao:
15 
16 t_inicial = time.time()
17 K = kcircle(largura, altura, raio , posicao_x, posicao_y)
18 tempo_kcircle = time.time() - t_inicial
19 
20 titulo = " kcircle() - tempo = %f" %tempo_kcircle
21 mmshow(uint16(K), title = titulo )
22 
23 t_inicial = time.time()
24 K = kcircle(largura, altura, raio , posicao_x, posicao_y)
25 tempo_kcircle = time.time() - t_inicial
26 
27 titulo = " kcircle() APOS LOAD DAS BIBLIOTECAS - tempo = %f" %tempo_kcircle
28 mmshow(uint16(K), title = titulo )
29 
30 delta_tempo = tempo_kcircle - tempo_iacircle
31 print "kcircle() em relacao a iacircle():"
32 print "Tempo de execucao iacircle() = %f" %tempo_iacircle
33 print "Tempo de execucao kcircle() = %f" %tempo_kcircle
34 print "Tempo kcircle() - iacircle() = %f" %delta_tempo
kcircle() em relacao a iacircle():
Tempo de execucao iacircle() = 0.002093
Tempo de execucao kcircle() = 0.002689
Tempo kcircle() - iacircle() = 0.000596

kcircle() - tempo = 0.003148

kcircle() APOS LOAD DAS BIBLIOTECAS - tempo = 0.002689

Percebemos que esta nova funcao, usando esses valores, e' quase tao rapida quanto iacircle().


Implementar a funcao iacos:

iacos

f = iacos (s, t, theta, phi)

Esta funcao gera imagens cossenoidais.

Observacao: a documentacao da funcao nao esta correta, por isso as divergencias nas descricoes aqui apresentadas.

1.Primeiro verificamos os parametros da funcao.

s = as dimencoes da imagem [altura, largura]

t = periodo

theta = Fase

phi = direcao espacial da onda. 0 eh uma onda na direcao horizontal

f = Imagem resultante

2.Testamos a funcao executando o seguinte codigo:

 1 import math
 2 
 3 periodo = 100
 4 direcao = math.pi/4
 5 fase = 0
 6 
 7 
 8 t_inicial = time.time()
 9 F = iacos([altura,largura], periodo, direcao, fase)
10 tempo_iacos = time.time() - t_inicial
11 
12 F = ianormalize(F, [0,255])
13 
14 titulo = "iacos() - tempo = %f" %tempo_iacos
15 mmshow(uint16(F), title = titulo )
16 
17 t_inicial = time.time()
18 F = iacos([altura,largura], periodo, direcao, fase)
19 tempo_iacos = time.time() - t_inicial
20 
21 F = ianormalize(F, [0,255])
22 
23 titulo = "iacos() APOS LOAD DAS BIBLIOTECAS - tempo = %f" %tempo_iacos
24 mmshow(uint16(F), title = titulo )

iacos() - tempo = 0.005807

iacos() APOS LOAD DAS BIBLIOTECAS - tempo = 0.005026

3.Para criar nossa implementacao, consideramos a equacao que descreve a funcao como sendo:

  1. Faremos uma versao inicial simples, usando "for" varrendo x e y e verificando se coloca uns ou zero na matriz imagem
 1 # Implementando a funcao iacos
 2 
 3 def kcos_usando_for(largura_da_imagem, altura_da_imagem, periodo_do_cosseno, angulo_de_direcao, fase_inicial_do_cosseno):
 4 
 5     matriz_da_imagem = zeros((altura_da_imagem, largura_da_imagem))
 6     T = periodo_do_cosseno
 7     Theta= angulo_de_direcao
 8     Phi =  fase_inicial_do_cosseno
 9 
10     fx = math.cos(Theta) / T
11     fy = math.sin(Theta) / T
12 
13     for x in range(0, largura_da_imagem):
14         for y in range(0, altura_da_imagem):
15             matriz_da_imagem[y,x] = math.cos( 2*math.pi*(fx*x + fy*y) + Phi)
16 
17     return matriz_da_imagem
18 
19 # def kcos_usando_for
20 
21 
22 # main
23 
24 t_inicial = time.time()
25 F = kcos_usando_for(largura, altura, periodo, direcao, fase)
26 tempo_kcos_usando_for = time.time() - t_inicial
27 
28 F = ianormalize(F, [0,255])
29 
30 titulo = "kcos_usando_for() - tempo = %f" %tempo_kcos_usando_for
31 mmshow(uint16(F), title = titulo )
32 
33 t_inicial = time.time()
34 F = kcos_usando_for(largura, altura, periodo, direcao, fase)
35 tempo_kcos_usando_for = time.time() - t_inicial
36 
37 F = ianormalize(F, [0,255])
38 
39 titulo = "kcos_usando_for() APOS LOAD DAS BIBLIOTECAS - tempo = %f" %tempo_kcos_usando_for
40 mmshow(uint16(F), title = titulo )
41 
42 delta_tempo = tempo_kcos_usando_for - tempo_iacos
43 print "kcos_usando_for() em relacao a iacos():"
44 print "Tempo de execucao iacos() = %f" %tempo_iacos
45 print "Tempo de execucao kcos_usando_for() = %f" %tempo_kcos_usando_for
46 print "Tempo kcos_usando_for() - iacos() = %f" %delta_tempo
kcos_usando_for() em relacao a iacos():
Tempo de execucao iacos() = 0.005026
Tempo de execucao kcos_usando_for() = 0.068438
Tempo kcos_usando_for() - iacos() = 0.063412

kcos_usando_for() - tempo = 0.068343

kcos_usando_for() APOS LOAD DAS BIBLIOTECAS - tempo = 0.068438

  1. Agora faremos uma versao usando matriz.
 1 # Implementando a funcao iacos
 2 
 3 def kcos(largura_da_imagem, altura_da_imagem, periodo_do_cosseno, angulo_de_direcao, fase_inicial_do_cosseno):
 4 
 5     T = periodo_do_cosseno
 6     Theta= angulo_de_direcao
 7     Phi =  fase_inicial_do_cosseno
 8 
 9     matriz_y, matriz_x = mgrid[0:altura_da_imagem, 0:largura_da_imagem]
10 
11     fx = math.cos(Theta) / T
12     fy = math.sin(Theta) / T
13 
14     matriz_da_imagem =  numpy.cos(2*math.pi*(fx*matriz_x + fy*matriz_y) + Phi)
15 
16     return matriz_da_imagem
17 
18 # def
19 
20 
21 
22 # main
23 
24 t_inicial = time.time()
25 F = kcos(largura, altura, periodo, direcao, fase)
26 tempo_kcos = time.time() - t_inicial
27 
28 F = ianormalize(F, [0,255])
29 
30 titulo = "kcos() - tempo = %f" %tempo_kcos
31 mmshow(uint16(F), title = titulo )
32 
33 t_inicial = time.time()
34 F = kcos(largura, altura, periodo, direcao, fase)
35 tempo_kcos = time.time() - t_inicial
36 
37 F = ianormalize(F, [0,255])
38 
39 titulo = "kcos() APOS LOAD DAS BIBLIOTECAS - tempo = %f" %tempo_kcos
40 mmshow(uint16(F), title = titulo )
41 
42 delta_tempo = tempo_kcos - tempo_iacos
43 print "kcircle() em relacao a iacircle():"
44 print "Tempo de execucao iacos() = %f" %tempo_iacos
45 print "Tempo de execucao kcos() = %f" %tempo_kcos
46 print "Tempo kcos() - iacos() = %f" %delta_tempo
kcircle() em relacao a iacircle():
Tempo de execucao iacos() = 0.005026
Tempo de execucao kcos() = 0.004914
Tempo kcos() - iacos() = -0.000112

kcos() - tempo = 0.005471

kcos() APOS LOAD DAS BIBLIOTECAS - tempo = 0.004914

Observe que a funcao seno utilizada nesta ultima implementacao foi a numpy.cos() e nao a math.sin(), isto porque a math.cos() nao aceita matriz como parametro, porem a numpy.cos() aceita.

Autor:gkaneblai
Data:15/03/2009