Autor: lemeluciano
Data: 01/06/2011

Funções Polar

Função utilizada no exemplo 1.

  • g = iaPolar(f, M, N)

Entrada. - f: Imagem original. Obrigatório - MP, NP: Dimensões da imagem. Obrigatório

Saída. - g: Imagem em coordenadas polares.

Função Polar com Interpolação Pedro

 1 from numpy import *
 2 from luc_14a import *
 3 def iapolar(f, MP, NP):
 4     m,n = f.shape
 5     R = floor(m/2)
 6     f[R,:] = (f[R-1,:]+f[R+1,:])/2
 7     f[:,R] = (f[:,R-1]+f[:,R+1])/2
 8     b = R/MP
 9     a = pi/NP
10     xl,yl = meshgrid(arange(NP),arange(MP))
11     XI = R + (b*yl)*cos(a*xl)
12     YI = R + (b*yl)*sin(a*xl)
13     g = iainterpolacao(f, XI, YI)
14     g = g[50:200,:]
15     return g, a

Funções Filtro

  • g = iafiltrof(s, xi, yi, xf, yf)
Entrada.
s : tamanho do filtro xi : posição da linha inicial yi : posição da coluna inicial xf : posição da linha final yf : posição da coluna final

Saída. - g: Banda Filtrada.

1 from numpy import *
2 def iafiltrof(s, xi, yi, xf, yf):
3     g = ones(size(s));
4     g[xi:xf,yi:yf]=0
5     return g

Funções Interpolação

 1 from numpy import *
 2 def iainterpolacao(f, XI, YI):
 3     m,n = XI.shape
 4     g = zeros((m,n))
 5     for i in arange(m):
 6         for j in arange(n):
 7             if XI[i,j]==floor(XI[i,j]):
 8                 px1 = 1
 9                 px2 = 0
10             else:
11                 px1 = XI[i,j]-floor(XI[i,j])
12                 px2 = ceil(XI[i,j])-XI[i,j]
13 
14             if YI[i,j]==floor(YI[i,j]):
15                 py1 = 1
16                 py2 = 0
17             else:
18                 py1 = YI[i,j]-floor(YI[i,j])
19                 py2 = ceil(YI[i,j])-YI[i,j]
20             p1 = (px1*py1)*f[floor(YI[i,j]),floor(XI[i,j])]
21             p2 = (px1*py2)*f[ceil(YI[i,j]),floor(XI[i,j])]
22             p3 = (px2*py1)*f[floor(YI[i,j]),ceil(XI[i,j])]
23             p4 = (px2*py2)*f[ceil(YI[i,j]),ceil(XI[i,j])]
24             g[i,j] = round(p1+p2+p3+p4)
25     return g

Testes

Rotação Usando Iaffine

 1 from ia636 import *
 2 from luc_13b import *
 3 import numpy as np
 4 
 5 f = adread('cameraman.pgm')
 6 adshow(f, title="Imagem original")
 7 t0=pi/6
 8 tx  = [[cos(t0),-sin(t0),0], [sin(t0),cos(t0),0], [0,0,1]]
 9 w = iaffine(f, tx)
10 adshow(w,"Imagem Rotacionada")

Imagem original

Imagem Rotacionada

Translação Usando Iaffine

 1 from ia636 import *
 2 from luc_13b import *
 3 import numpy as np
 4 
 5 f = adread('cameraman.pgm')
 6 adshow(f, title="Imagem original")
 7 
 8 Tx   = [[1,0,0], [0,1,80], [0,0,1]]
 9 w = iaffine(f, Tx)
10 adshow(w, title  = 'Imagem - Translação')

Imagem original

Imagem - Translação

Exemplos

Exemplo 1

 1 from ia636 import *
 2 from luc_13b import *
 3 from luc_14a import *
 4 import numpy as np
 5 
 6 #f = adread('club.pgm')
 7 f = mmreadgray('db1_a/1_1.tif')
 8 f2 = mmreadgray('db1_a/1_1.tif')
 9 
10 # criando uma imagem parecida
11 w = f[05:05+50,106:106+50]
12 f2 = zeros(array(f.shape),dtype=uint8)
13 f2[:w.shape[0],:w.shape[1]] = w
14 f2 = uint8(ianormalize(f2, [1,254]))
15 adshow(f, title="Imagem original")
16 adshow(f2, title="Imagem Procurada")
17 print "Imprimindo Informações"
18 print "----------------------"
19 
20 # Primeiro Passo : Verifica se as imagens são Iguais"
21 if iaimginfo(f) <> iaimginfo(f2):
22    print "Imagens não Compativeis"
23 else:
24    print "Imagens Compativeis"
25 
26 # Segundo passo: DFT das imagens
27 F1 = fft.fft2(f)            # calcula a transformada de fourier (fft - n dimencional)
28 F2 = fft.fft2(f2)           # calcula a transformada de fourier (fft - n dimencional)
29 adshow(iadftview(F1),'DFT - F1')
30 adshow(ianormalize(iadftview(F2)),'DFT - F2')
31 F1 = abs(iafftshift(F1));
32 F2 = abs(iafftshift(F2));
33 
34 print 'F1 é simetrico conjugado ? ',iaisdftsym(F1)
35 print 'F2 é simetrico conjugado ? ',iaisdftsym(F2)
36 
37 # Terceiro passo: conversão para coordenadas polares
38 F1p,a = iapolar(F1,120,120)
39 adshow(F1p,"F1 - Polar")
40 F2p,b = iapolar(F2,120,120)
41 adshow(F2p,"F2 - Polar")
42 
43 # Quarto passo: correlacao de fase
44 F1f = iadft(F1p)
45 F2f = iadft(F2p)
46 
47 R = (F1f *conjugate(F2f))/abs(F1f*conjugate(F2f))
48 r = real(iaidft(R))
49 linha, coluna = iaind2sub(r.shape,argmax(ravel(r)))
50 
51 # Quinto Passo: converte o Angulo para Radiano (Opcional desde que faca a conversao depois)
52 t0 = coluna*pi/(180*0.5)
53 print "Angulo em Radiano:",t0
54 
55 # Sexto Passo : girando a imagem
56 tx  = [[cos(t0),-sin(t0),0], [sin(t0),cos(t0),0], [0,0,1]]
57 g = iaffine(f, tx)
58 adshow(g,"Imagem Rotacionada")
59 
60 # Sexto Passo : fazer a correlacao de fase
61 g1 = iadft(g)
62 R2 = (f*conjugate(g1))/abs(f*conjugate(g1))
63 r2 = real(iaidft(R2))
64 print "Ponto central da região de maior correlação [1]:(", linha, ",",coluna,")"
65 linha2, coluna2 = iaind2sub(r2.shape,argmax(ravel(r2)))
66 print "Ponto central da região de maior correlação [2]:(", linha2, ",",coluna2,")"
ERROR execute
Imprimindo Informações
----------------------
Imagens Compativeis
F1 é simetrico conjugado ?  True
F2 é simetrico conjugado ?  True
------------------------------------------------------------
*** Exception while evaluating code:
  File "<string>", line 38, in <module>
  File "/home/rubens/www/packages/ia636/iapolar.py", line 9, in iapolar
    dm,dn = domain
TypeError: 'int' object is not iterable

------------------------------------------------------------

Imagem original

Imagem Procurada

DFT - F1

DFT - F2