Exercício 2 de IA636-2009

Estudar as várias funções sintéticas da toolbox ia636, utilizando-as com parâmetros interessantes. Escolher uma ou duas para implementá-la, utilizando o meshgrid.

Autor:Matias
Data:19/03/2009

Observações sobre as comparações de tempo

  • Como observado pelo Gustavo Kaneblai, parece haver um overhead na primeira vez que se chama funções, o que atrapalha a comparação de tempo.
  • Para tentar manter as comparações válidas, todas as funções foram chamadas duas vezes.

Função iacircle

Segundo a documentação do toolbox, o comando iacircle aplica a seguinte equação para gerar uma imagem de um circulo preenchido:

A função iacircle é chamada da seguinte forma:

  • iacircle(s, r, c)
  • iacircle_2(s, r, c)
Onde:
  • s: dimensões da imagem.
  • r: raio
  • c: centro do circulo

A implementação feita para esse exercício segue exatamente a mesma interface de chamada e a mesma equação como base de implementação.

1 def iacircle_2(tamanho,raio,centro):
2     centro_x=centro[0]
3     centro_y=centro[1]
4     tamanho_x=tamanho[0]
5     tamanho_y=tamanho[1]
6     raio_quadrado=raio**2
7     X,Y = meshgrid(range(0,tamanho_x),range(0,tamanho_y))
8     imagem = (((X - centro_x)**2 + (Y - centro_y)**2 ) < raio_quadrado)
9     return imagem

Chamadas da função original:

1 time1 = time.time()
2 mmshow(iacircle([100,100],35,[50,50]),title = "iacircle: "+str(round((time.time()-time1)*1000,5))+"ms")
3 time1 = time.time()
4 mmshow(iacircle([100,100],35,[50,50]),title = "iacircle: "+str(round((time.time()-time1)*1000,5))+"ms")

iacircle: 0.72002ms

iacircle: 0.314ms

Chamadas da função implementada para esse exercício:

1 time1 = time.time()
2 mmshow(iacircle_2([100,100],35,[50,50]),title = "iacircle_2: "+str(round((time.time()-time1)*1000,5))+"ms")
3 time1 = time.time()
4 mmshow(iacircle_2([100,100],35,[50,50]),title = "iacircle_2: "+str(round((time.time()-time1)*1000,5))+"ms")

iacircle_2: 0.46086ms

iacircle_2: 0.27204ms

Função iaramp

A equação na documentação do toolbox é esta:

E a chamada da função se dá por:

  • iarange(s, n, range)
  • iarange_2(s, n, range)
Onde:
  • s: dimensões da imagem.
  • n: número de fatias
  • range: valores mínimos e máximos do tom de cinza.

A implementação aqui imita a funcionalidade e segue, a principio a mesma lógica. Entretanto foi feito uma implementação alternativa do que usar o comando "floor" do python.

 1 def iaramp_2(tamanho,n_faixas,cor):
 2     cor_min=cor[0]
 3     cor_max=cor[1]
 4     tamanho_x=tamanho[0]
 5     tamanho_y=tamanho[1]
 6     x_passo = float(tamanho_x) / float(n_faixas)
 7     cor_passo = float(cor_max-cor_min) / float(n_faixas-1)
 8     X,Y = meshgrid(range(0,tamanho_x),range(0,tamanho_y))
 9     X = X.astype(float)
10     imagem =  ((X // float(x_passo)) * cor_passo) + cor_min
11     return imagem

Chamadas da função original:

1 time1 = time.time()
2 mmshow(uint16(iaramp([100,200],10,[0,255])),title = "iaramp: "+str(round((time.time()-time1)*1000,5))+"ms")
3 time1 = time.time()
4 mmshow(uint16(iaramp([100,200],10,[0,255])),title = "iaramp: "+str(round((time.time()-time1)*1000,5))+"ms")

iaramp: 1.74403ms

iaramp: 1.30606ms

Chamadas da função implementada para esse exercício:

1 time1 = time.time()
2 mmshow(uint16(iaramp_2([200,100],10,[0,255])),title = "iaramp_2: "+str(round((time.time()-time1)*1000,5))+"ms")
3 time1 = time.time()
4 mmshow(uint16(iaramp_2([200,100],10,[0,255])),title = "iaramp_2: "+str(round((time.time()-time1)*1000,5))+"ms")

iaramp_2: 0.90814ms

iaramp_2: 0.85187ms

Uma observação importante: o comando mmshow normaliza a imagem sendo exibida. Assim, para se ver tons de cinza que não vão do preto total (0) até o branco total (255) é necessário fazer algumas adaptações.

Função iarectangle

Mais uma vez, a função implementada aqui imita o funcionamento da original do toolbox. A lógica seguida também é exatamente a mesma:

Com a seguinte chamada:

  • iarectangle(s, n, range)
  • iarecantagle_2(s, n, range)
Onde:
  • s: dimensões da imagem.
  • r: número de fatias
  • c: valores mínimos e máximos do tom de cinza.
 1 def iarectangle_2(tamanho,tamanho_retangulo,centro_retangulo):
 2 
 3     tamanho_x=tamanho[0]
 4     tamanho_y=tamanho[1]
 5     retangulo_vertice_1_x=centro_retangulo[0]-tamanho_retangulo[0]/2
 6     retangulo_vertice_1_y=centro_retangulo[1]-tamanho_retangulo[1]/2
 7     retangulo_vertice_2_x=centro_retangulo[0]+tamanho_retangulo[0]/2
 8     retangulo_vertice_2_y=centro_retangulo[1]+tamanho_retangulo[1]/2
 9 
10     X,Y = meshgrid(range(0,tamanho_x),range(0,tamanho_y))
11     imagem = ((X <= retangulo_vertice_2_x) & (X >= retangulo_vertice_1_x)) & ((Y <= retangulo_vertice_2_y) & (Y >= retangulo_vertice_1_y))
12     return imagem

Chamadas da função original:

1 time1 = time.time()
2 mmshow(uint16(iarectangle([200,200],[100,100],[100,100])),title = "iarectangle: "+str(round((time.time()-time1)*1000,5))+"ms")
3 time1 = time.time()
4 mmshow(uint16(iarectangle([200,200],[100,100],[100,100])),title = "iarectangle: "+str(round((time.time()-time1)*1000,5))+"ms")

iarectangle: 2.11096ms

iarectangle: 1.62911ms

Chamadas da função implementada para esse exercício:

1 time1 = time.time()
2 mmshow(uint16(iarectangle_2([200,200],[100,100],[100,100])),title = "iarectangle_2: "+str(round((time.time()-time1)*1000,5))+"ms")
3 time1 = time.time()
4 mmshow(uint16(iarectangle_2([200,200],[100,100],[100,100])),title = "iarectangle_2: "+str(round((time.time()-time1)*1000,5))+"ms")

iarectangle_2: 1.4801ms

iarectangle_2: 1.36399ms

Função iagaussian

Infelizmente, as tentaivas de chamar a iagassian aqui falharam por algum motivo, então não é possível fazer uma comparação de tempo.

De qualquer forma, a função implementada aqui é diferente da documentada no toolbox. Essa é restrita a geração de uma imagem 2D gaussiana, enquanto que a a função do toolbox não tem essa limitação.

Mesmo se considerando apenas o espaço 2D, ainda existe uma diferença na equação considerada aqui:

A diferença está na constante A. Na implemntação do toolbox, ela é calculada através dos parametros sigmas fornecidos. Aqui ela é fornecida na chamada.

Chamada da função original do toolbox:

  • iagaussian( s, mu, sigma )
Onde:
  • s: tamanho da imagem.
  • mu: Vetor mediano. Ponto de valor máximo
  • sigma: constantes sigmas, em uma forma matricial: [Sx^2, Sxy; Syx, Sy^2]

Para a função criada aqui (iagaussian_2) a seguinte é chamada é usada:

  • iagaussian2( s, mu, sigma, a)
Onde:
  • s: tamanho da imagem
  • mu: Vetor mediano. Ponto de valor máximo
  • sigma: constantes sigmas, na forma de um vetor: [Sx, Sy]
  • a: amplitude, constante A da equação.
 1 def iagaussian_2(tamanho, mu, sigma,amplitude):
 2     tamanho_x=tamanho[0]
 3     tamanho_y=tamanho[1]
 4     X,Y = meshgrid(range(0,tamanho_x),range(0,tamanho_y))
 5     sigma_x=float(sigma[0]);
 6     sigma_y=float(sigma[1]);
 7     mu_x=mu[0]
 8     mu_y=mu[1]
 9     X = X.astype(float)
10     Y = Y.astype(float)
11     imagem = amplitude * exp( -1./2 * ((((X - mu_x)/sigma_x)**2) + (((Y - mu_y)/sigma_y)**2 ) ))
12     return imagem
13 
14 time1 = time.time()
15 mmshow(uint16(iagaussian_2([150,200], [75,70], [20,40],50)),title = "iagaussian_2: "+str(round((time.time()-time1)*1000,5))+"ms")
16 time1 = time.time()
17 mmshow(uint16(iagaussian_2([150,200], [75,70], [20,40],50)),title = "iagaussian_2: "+str(round((time.time()-time1)*1000,5))+"ms")

iagaussian_2: 3.41201ms

iagaussian_2: 3.04604ms