Exercício 06 - Convolução

Autor: Wagner Machado do Amaral
Data: 22/04/2009

Enunciado: ia636-2009:exercicio6

A função abaixo é a implementação da convolução discreta periódica, essa função foi implementada utilizando a tradicional varredura de pixels.

Entrada de dados:

  • I - Imagem de entrada a ser transformada
  • M - Matriz 3x3 da mascara de transformação a ser aplicada

Saída de dados:

  • I2 - Imagems I transformada pela mascara M
 1 def convolucao(I,M):
 2   M = ravel(M)
 3   I = iapad(I,(1,1),1)
 4   I2 = zeros(I.shape)
 5   m,n = I.shape
 6   for fm in range(1,m-1):
 7     for fn in range(1,n-1):
 8       I_ = ravel( I[ fm-1:fm+2, fn-1:fn+2 ] )
 9       I2[fm,fn] = inner(I_,M)
10   I2 = iaroi( I2 , [1,1], [m-2,n-2] )
11   return I2

Segue abaixo um exemplo retirado da prova 1 dessa disciplina.

Nesse exemplo uma imagem branca com um quadrado preto no centro da imagem é submetida a um operador laplaciano.

 1 I = ones([9,9])
 2 I[3:6, 3:6] = zeros([3,3])
 3 print 'Imagem de entrada'
 4 print I
 5 M = asarray( [[0,1,0],[1,-4,1],[0,1,0]] )
 6 print 'operador laplaciano'
 7 print M
 8 I2 = convolucao(I,M)
 9 print 'Laplaciano aplicado na imagem acima'
10 print I2
Imagem de entrada
[[ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  0.  0.  0.  1.  1.  1.]
 [ 1.  1.  1.  0.  0.  0.  1.  1.  1.]
 [ 1.  1.  1.  0.  0.  0.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.]]
operador laplaciano
[[ 0  1  0]
 [ 1 -4  1]
 [ 0  1  0]]
Laplaciano aplicado na imagem acima
[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0. -1. -1. -1.  0.  0.  0.]
 [ 0.  0. -1.  2.  1.  2. -1.  0.  0.]
 [ 0.  0. -1.  1.  0.  1. -1.  0.  0.]
 [ 0.  0. -1.  2.  1.  2. -1.  0.  0.]
 [ 0.  0.  0. -1. -1. -1.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.  0.  0.  0.]]

O exemplo abaixo apresenta o resultado do operador laplaciano aplicado a uma imagem real.

1 I = mmreadgray('MVBook/club.png')
2 mmshow(I)
3 M = asarray( [[0,1,0],[1,-4,1],[0,1,0]] )
4 I2 = convolucao(I,M)
5 mmshow(I2)
Warning: downcasting image from double to uint16 (may lose precision)

Observe acima que o operador laplaciano detecta as bordas da imagem.

No exemplo abaixo é aplicado na imagem um operador de suavização 5 vezes consecutivas.

Operador aplicado:

1 I = mmreadgray('MVBook/jangada.png')
2 mmshow(I)
3 M = ones([3,3])/9
4 n=5
5 I2 = convolucao(I,M)
6 for f in range(1,n-1):
7   I2 = convolucao(I2,M)
8 mmshow(I2)
Warning: downcasting image from double to uint16 (may lose precision)

Observe acima que o operador de suavização "embaçou" um pouco a imagem.

Extraindo os dígitos da placa do carro

O objetivo do teste abaixo é utilizar algumas das transformações e convoluções aprendidas em aula para extrair os dígitos da placa de um carro em uma foto.

 1 from machadowma_iaffine import *
 2 
 3 I = mmreadgray('MDX4422.jpg')
 4 mmshow(I,title='MDX4422.jpg')
 5 
 6 I2 = iaroi( I , [147, 160], [168, 261] )
 7 
 8 M = ones([3,3])/9
 9 I2 = convolucao(I2,M)
10 I2 = convolucao(I2,M)
11 I2 = convolucao(I2,M)
12 
13 M = asarray( [[0,1,0],[1,-4,1],[0,1,0]] )
14 I2 = convolucao(I2,M)
15 
16 s = 6 #escala
17 m,n = I2.shape
18 I3 = zeros([m*s,n*s])
19 I3[ 0:m, 0:n ] = I2
20 M = [[s,0,0],[0,s,0],[0,0,1]]
21 I3 = machadowma_iaffine(I3,M)
22 
23 M = ones([3,3])/9
24 I3 = convolucao(I3,M)
25 I3 = convolucao(I3,M)
26 I3 = convolucao(I3,M)
27 
28 mmshow(I3,title='Placa do veículo')
Warning: downcasting image from double to uint16 (may lose precision)

MDX4422.jpg

Placa do veículo