jailton_Ex11

  1 #-1. Corrigir os erros do exercício entregue na semana passada, fazendo uma nova página com a nova solução
  2 #corrigida. Fazer um pequeno relatório mostrando onde estavam os erros.
  3 #Alguns erros: - Referência da origem das coordenadas na frequênica(filtro,imagem)
  4 #              - Ajustes do filtro(desvios padrão,período)
  5 #2.Fazer o exercício de classificação da orientação na imagem da impressão digital. Fazer no domínio da
  6 #frequência,ajustando bem a sintonia da distância entre as papilas.Classificar a orientação pelo ângulo
  7 #de dê a maior
  8 #resposta entre os diversos filtros de Gabor.
  9 #3.Repetir o exercício de realce, no domínio da frequência em duas opções:
 10 #3.1 fazendo-se a soma de todas as orientações dos filtros de Gabor
 11 #3.2 projetando-se um filtro "anelar" inspirado nas bordas do filtro de Butterworth.
 12 
 13 from numpy import mgrid,meshgrid
 14 from numpy.fft import fft2,ifft2,fftshift
 15 def jjnormaliza(fi,Lmax):   #Função normaliza
 16     minf=numpy.min(fi)
 17     delta=numpy.ptp(fi)
 18     fo=(fi-minf)*Lmax/delta
 19     return fo
 20 #--------------------------------------------------
 21 #1. Implementar o filtro de Gabor, tanto no domínio da frequência como no domínio espacial
 22 #--------------------------------------------------
 23 #- Filtro de Gabor 1: Fonte base: http://www.springerlink.com/content/u634617j37737743/fulltext.pdf
 24 #The Gabor function is defined as follows:
 25 #-G(x, y,|W,theta,fase,X,Y)= exp[-0.5*[(x - X)^2 + (y - Y)^2]/desvp^2]*sin(W(xcos(theta)-ysin(theta))+fase)
 26 #where devp is the Gaussian width, theta is the filter orientation,W is its frequency and fase is its phase shift.
 27 #X, Y define the center of the filter.
 28 #and G(x, y,|W,theta,fase,X,Y) the Gabor operator. We find the G * L spectra for various orientations and shifts.
 29 #This spectrum identifies the texture element.
 30 #--------------------------------------------------
 31 def jjgabor1(N,M,X,Y,desvp,w,anggrau,fasegrau):
 32     x, y = numpy.meshgrid(range(N),range(M))
 33     angrad=(anggrau*numpy.pi/180.0)
 34     faserad=(anggrau*numpy.pi/180.0)
 35     W=(2.0*numpy.pi*w/M)
 36     fo = (exp((((x-X)**2+(y-Y)**2))/(-2.0*desvp**2)))*sin(W*(x*cos(angrad)-y*sin(angrad))+faserad)
 37     return fo
 38 g1=jjgabor1(256,256,128,128,20,10,45,0)
 39 iashow(uint16(jjnormaliza(g1,255)),title = "jjgabor1-D. Espacial- anggrau=45,desvp=20,w=10,fase=0")
 40 guv=fft2(g1)
 41 guv1 = iadftview(guv)
 42 iashow(uint16(guv1), title = "jjgabor1-D. Frequência- anggrau=45,desvp=20,w=10,fase=0")
 43 #--------------------------------------------------
 44 g1=jjgabor1(256,256,100,100,20,10,120,0)
 45 iashow(uint16(jjnormaliza(g1,255)),title = "jjgabor1-D. Espacial- anggrau=120,desvp=20,w=10,fase=0")
 46 guv=fft2(g1)
 47 guv1 = iadftview(guv)
 48 iashow(uint16(guv1), title = "jjgabor1-D. Frequência- anggrau=120,desvp=20,w=10,fase=0")
 49 #--------------------------------------------------
 50 #- Fitro de Gabor 2: Fonte base: http://parati.dca.fee.unicamp.br/media/Attachments/ia636-2009/exercicio10/gaborfingerprint.pdf
 51 #--------------------------------------------------
 52 def jjgabor2(N,M,desvpx,desvpy,T,anggrau):
 53     x1, y1 = numpy.meshgrid(range(N),range(M))
 54     x=x1-N/2
 55     y=y1-M/2
 56     angrad=(-anggrau*numpy.pi/180.0)
 57     f=(2.0*pi/T)
 58     xf=(x*cos(angrad)+y*sin(angrad))
 59     yf=(-x*sin(angrad)+y*cos(angrad))
 60     fo = ((exp(-0.5*((xf/desvpx)**2+(yf/desvpy)**2)))*cos(f*xf))
 61     return fo
 62 g1=jjgabor2(256,256,20,20,20,-45)
 63 iashow(uint16(jjnormaliza(g1,255)),title = "jjgabor2-D. Espacial- anggrau=-45,desvpx=desvpy=20")
 64 guv=fft2(g1)
 65 guv1 = iadftview(guv)
 66 iashow(uint16(guv1), title = "jjgabor2-D. Frequência- anggrau=-45,desvpx=desvpy=20")
 67 #--------------------------------------------------
 68 g1=jjgabor2(256,256,20,20,20,-150)
 69 iashow(uint16(jjnormaliza(g1,255)),title = "jjgabor2-D. Espacial- anggrau=-150,desvpx=desvpy=20")
 70 guv=fft2(g1)
 71 guv1 = iadftview(guv)
 72 iashow(uint16((guv1)), title = "jjgabor2-D. Frequência- anggrau=-150,desvpx=desvpy=20")
 73 #--------------------------------------------------
 74 #--------------------------------------------------
 75 #--------------------------------------------------
 76 #2. Aplicar o filtro de Gabor em diversas direções e classificar a orientação das regiões do fingerprint.
 77 #--------------------------------------------------
 78 fxy1 = mmreadgray('db1_a/1_1.tif')
 79 iashow(fxy1, title = "Imagem de Entrada-D. Espacial")
 80 fuv=fft2(fftshift(fxy1))
 81 fuv1 = iadftview(fuv)
 82 iashow(fuv1, title = "Imagem de Entrada-D. Frequência")
 83 ang=0
 84 fo=fxy1*0
 85 guvt=fxy1*0
 86 limiar="sem limiar"
 87 while ang < 180:
 88     gxy1=jjgabor2(388,374,4.0,4.0,12.0,ang)
 89     guv=fft2(gxy1)
 90     guvt=guvt+guv
 91     GuvFuv=guv*fuv
 92     iashow(iadftview((GuvFuv)),title = "F(u,v)*G(u,v)-Ângulo = " + str(ang)+ " graus")
 93     ifxy=abs(ifft2(GuvFuv))
 94     iashow(uint16(jjnormaliza((ifxy),255)),title = "f(x,y)- Após Filtro Gabor-Ângulo = " + str(ang)+ " graus")
 95     ang=ang+15
 96     fo=fo + ifxy
 97 iashow(uint16(jjnormaliza(fo,255)),title = "Saída - f(x,y)-limiar = " + str(limiar))
 98 #--------------------------------------------------
 99 #3. Repetir o exercício de realce, no domínio da frequência em duas opções:
100 #3.1 fazendo-se a soma de todas as orientações dos filtros de Gabor
101 #3.2 projetando-se um filtro "anelar" inspirado nas bordas do filtro de Butterworth.
102 #--------------------------------------------------
103 iashow(iadftview(guvt),title = "Saída - Soma dos Filtros(Garbor)-guvt")
104 GFt=fuv*guvt
105 iashow(iadftview(GFt),title = "Saída - guvt*fuv - (soma filtros)*(imagem)")
106 ifxy=abs(ifft2(GFt))
107 iashow(uint16(jjnormaliza((ifxy),255)), title = "I de saída-após Soma Filtro Garbor-limiar = " + str(limiar))
108 def jjbutterworth(N,M,n,D0):
109     u, v = numpy.meshgrid(range(N),range(M))
110     D=((u-N/2)**2+(v-M/2)**2)**0.5
111     Huv=1.0/(1.0+(D/D0)**(2*n))
112     return Huv
113 n1=6
114 D01=72.0
115 n2=6
116 D02=20.0
117 filtro1=(jjbutterworth(388,374,n1,D01)-jjbutterworth(388,374,n2,D02))
118 iashow(uint16(jjnormaliza(filtro1,255)),title = "Filtro Butterworth- n1= "+ str(n1) + " D01= " + str(D01))
119 FGbutter=fftshift(filtro1)*(fuv)
120 iashow(iadftview(FGbutter),title = "Saída - (filtroButterworth)*fuv")
121 ifxy=fftshift(abs(ifft2(FGbutter)))
122 iashow(uint16(jjnormaliza((ifxy),255)), title = "Imag. de saída-após Filtro de Butterworth")

jjgabor1-D. Espacial- anggrau=45,desvp=20,w=10,fase=0

jjgabor1-D. Frequência- anggrau=45,desvp=20,w=10,fase=0

jjgabor1-D. Espacial- anggrau=120,desvp=20,w=10,fase=0

jjgabor1-D. Frequência- anggrau=120,desvp=20,w=10,fase=0

jjgabor2-D. Espacial- anggrau=-45,desvpx=desvpy=20

jjgabor2-D. Frequência- anggrau=-45,desvpx=desvpy=20

jjgabor2-D. Espacial- anggrau=-150,desvpx=desvpy=20

jjgabor2-D. Frequência- anggrau=-150,desvpx=desvpy=20

Imagem de Entrada-D. Espacial

Imagem de Entrada-D. Frequência

F(u,v)*G(u,v)-Ângulo = 0 graus

f(x,y)- Após Filtro Gabor-Ângulo = 0 graus

F(u,v)*G(u,v)-Ângulo = 15 graus

f(x,y)- Após Filtro Gabor-Ângulo = 15 graus

F(u,v)*G(u,v)-Ângulo = 30 graus

f(x,y)- Após Filtro Gabor-Ângulo = 30 graus

F(u,v)*G(u,v)-Ângulo = 45 graus

f(x,y)- Após Filtro Gabor-Ângulo = 45 graus

F(u,v)*G(u,v)-Ângulo = 60 graus

f(x,y)- Após Filtro Gabor-Ângulo = 60 graus

F(u,v)*G(u,v)-Ângulo = 75 graus

f(x,y)- Após Filtro Gabor-Ângulo = 75 graus

F(u,v)*G(u,v)-Ângulo = 90 graus

f(x,y)- Após Filtro Gabor-Ângulo = 90 graus

F(u,v)*G(u,v)-Ângulo = 105 graus

f(x,y)- Após Filtro Gabor-Ângulo = 105 graus

F(u,v)*G(u,v)-Ângulo = 120 graus

f(x,y)- Após Filtro Gabor-Ângulo = 120 graus

F(u,v)*G(u,v)-Ângulo = 135 graus

f(x,y)- Após Filtro Gabor-Ângulo = 135 graus

F(u,v)*G(u,v)-Ângulo = 150 graus

f(x,y)- Após Filtro Gabor-Ângulo = 150 graus

F(u,v)*G(u,v)-Ângulo = 165 graus

f(x,y)- Após Filtro Gabor-Ângulo = 165 graus

Saída - f(x,y)-limiar = sem limiar

Saída - Soma dos Filtros(Garbor)-guvt

Saída - guvt*fuv - (soma filtros)*(imagem)

I de saída-após Soma Filtro Garbor-limiar = sem limiar

Filtro Butterworth- n1= 6 D01= 72.0

Saída - (filtroButterworth)*fuv

Imag. de saída-após Filtro de Butterworth