Transformação Geométrica

Autor: cronuxs
Data: 31/03/2009

Exercício

  1. Equação matemática do uso indexado imagens no Python.

2. Estudar a função iaffine da toolbox ia636. Ver como funciona exercitando com valores interessantes. Entender como funciona a sua codificação.

  1. Fazer uma nova função, utilizando o mapeamento direto.
  2. Opcionalmente, melhorar a função iaffine.

Resolução

Item 1

  • Como:
  • Sendo X e Y matrizes de tamanho igual
  • As matrizes X e Y representam indices.
  • Portanto:
  • Assim é possivel notar que a matriz resultante tem mesmas dimenções da matriz X e Y.
  • Exemplo:
 1 from ia636 import *
 2 w = 10
 3 
 4 M = arange(w*w).reshape((w,w))
 5 print "Matriz M:",M
 6 
 7 X = array([[0,2,4],[6,8,0],[6,0,8]])
 8 Y = array([[0,2,4],[6,8,6],[0,8,0]])
 9 
10 print "Matriz X:",X
11 print "Matriz Y:",Y
12 
13 print "Matriz C:",M[X,Y]
Matriz M: [[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]
Matriz X: [[0 2 4]
 [6 8 0]
 [6 0 8]]
Matriz Y: [[0 2 4]
 [6 8 6]
 [0 8 0]]
Matriz C: [[ 0 22 44]
 [66 88  6]
 [60  8 80]]

Item 2

 1 FILENAME = 'cameraman.pgm'
 2 angle = math.radians(45)
 3 scale = 2
 4 
 5 def iaffineCorrigido(f, T):
 6 
 7     f, T = asarray(f), asarray(T)
 8     faux = ravel(f)
 9     if len(f.shape) == 1:
10         f = f[newaxis,:]
11     (m, n) = f.shape
12     (x, y) = iameshgrid(range(n),range(m))
13     aux = concatenate((reshape(x, (1,m*n)), reshape(y, (1,m*n))))
14     aux = concatenate((aux, ones((1, m*n))))
15     XY = dot(linalg.inv(T), aux)
16     X, Y = XY[0,:], XY[1,:]
17     X = maximum(0, minimum(n-1, X))
18     Y = maximum(0, minimum(m-1, Y))
19     XYi = iasub2ind(f.shape, map(round, Y), map(round, X))
20     g = take(faux, XYi)
21     g = reshape(g, f.shape)
22     return g
23 
24 I = mmreadgray(FILENAME)
25 Translacao = array( [   [1,0,I.shape[0]/2],
26                         [0,1,I.shape[1]/2],
27                         [0,0,1] ] , 'd')
28 Rotacao = array(    [   [ cos(angle), sin(angle),0],
29                         [-sin(angle), cos(angle),0],
30                         [0,0,1] ] , 'd')
31 Escala = array(     [   [scale,0,0],
32                         [0,scale,0],
33                         [0,0,1] ] , 'd')
34 T = array(          [   [1,0,0],
35                         [0,1,0],
36                         [0,0,1] ] , 'd')
37 T = dot(T,Translacao)
38 T = dot(T,Rotacao)
39 #T = dot(T,Escala)
40 T = dot(T,linalg.inv(Translacao))
41 
42 print T
43 
44 mmshow(I)
45 
46 I2 = iaffine(I,T)
47 I3 = iaffineCorrigido(I,T)
48 
49 mmshow(I2)
50 mmshow(I3)
51 
52 print I
53 print I2
[[   0.70710678    0.70710678  -53.01933598]
 [  -0.70710678    0.70710678  128.        ]
 [   0.            0.            1.        ]]
[[169 168 174 ..., 194 191 193]
 [174 175 176 ..., 188 186 186]
 [171 178 172 ..., 195 188 191]
 ..., 
 [178 183 183 ..., 144 186 174]
 [187 180 157 ..., 148 183 152]
 [169 170 160 ..., 160 198 165]]
[[201 197 197 ..., 225 227 227]
 [197 201 197 ..., 227 227 225]
 [197 197 201 ..., 227 225 222]
 ..., 
 [182 190 190 ..., 194 195 195]
 [190 190 158 ..., 194 194 195]
 [190 158 167 ..., 194 194 194]]

Item 3

 1 from math import *
 2 
 3 FILENAME = 'cameraman.pgm'
 4 
 5 def iaffineDireto(I,T):
 6     m,n = I.shape;
 7     x,y = iameshgrid(arange(m),arange(n));
 8 
 9     PtosHomogenio = array([ x.reshape(m*n), y.reshape(m*n), ones(m*n) ])
10     PtosHomogenioLinha = dot(T, PtosHomogenio)
11 
12     xlinha = PtosHomogenioLinha[0].round(0).astype(int)
13     ylinha = PtosHomogenioLinha[1].round(0).astype(int)
14 
15     Xnovo = transpose(maximum(0, minimum(m-1, xlinha)).reshape(n,m))
16     Ynovo = transpose(maximum(0, minimum(n-1, ylinha)).reshape(n,m))
17 
18     C = zeros((m,n))
19     C[Xnovo,Ynovo] = I
20 
21     return C
22 
23 
24 angle = math.radians(45)
25 scale = 2
26 
27 I = mmreadgray(FILENAME)
28 Translacao = array( [   [1,0,I.shape[0]/2],
29                         [0,1,I.shape[1]/2],
30                         [0,0,1] ] , 'd')
31 Rotacao = array(    [   [ cos(angle),-sin(angle),0],
32                         [ sin(angle), cos(angle),0],
33                         [0,0,1] ] , 'd')
34 Escala = array(     [   [scale,0,0],
35                         [0,scale,0],
36                         [0,0,1] ] , 'd')
37 T = array(          [   [1,0,0],
38                         [0,1,0],
39                         [0,0,1] ] , 'd')
40 T = dot(T,Translacao)
41 T = dot(T,Rotacao)
42 #T = dot(T,Escala)
43 T = dot(T,linalg.inv(Translacao))
44 
45 mmshow(I)
46 
47 I2 = iaffineDireto(I,T)
48 
49 mmshow(I2)
Warning: downcasting image from double to uint16 (may lose precision)

Item 4

Re implementação do método iaffine

 1 def iaffineIndireto(I,T):
 2     m,n = I.shape;
 3     x,y = iameshgrid(arange(m),arange(n));
 4 
 5     PtosHomogenio = array([ x.reshape(m*n), y.reshape(m*n), ones(m*n) ])
 6     PtosHomogenioLinha = dot(linalg.inv(T), PtosHomogenio)
 7 
 8     xlinha = PtosHomogenioLinha[0].round(0).astype(int)
 9     ylinha = PtosHomogenioLinha[1].round(0).astype(int)
10 
11     Xnovo = transpose(maximum(0, minimum(m-1, xlinha)).reshape(n,m))
12     Ynovo = transpose(maximum(0, minimum(n-1, ylinha)).reshape(n,m))
13 
14     C = I[Xnovo,Ynovo]
15 
16     return C
17 
18 from math import *
19 
20 FILENAME = 'cameraman.pgm'
21 
22 angle = math.radians(45)
23 scale = 2
24 
25 I = mmreadgray(FILENAME)
26 Translacao = array( [   [1,0,I.shape[0]/2],
27                         [0,1,I.shape[1]/2],
28                         [0,0,1] ] , 'd')
29 Rotacao = array(    [   [ cos(angle),-sin(angle),0],
30                         [ sin(angle), cos(angle),0],
31                         [0,0,1] ] , 'd')
32 Escala = array(     [   [scale,0,0],
33                         [0,scale,0],
34                         [0,0,1] ] , 'd')
35 T = array(          [   [1,0,0],
36                         [0,1,0],
37                         [0,0,1] ] , 'd')
38 T = dot(T,Translacao)
39 T = dot(T,Rotacao)
40 #T = dot(T,Escala)
41 T = dot(T,linalg.inv(Translacao))
42 
43 mmshow(I)
44 
45 I2 = iaffineIndireto(I,T)
46 
47 mmshow(I2)