-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.py
226 lines (172 loc) · 7.07 KB
/
main.py
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
'''
LABORATORIO 2: CONVOLUCION 2D
Estudiante: Francisco Rousseau
Ayudante: Nicole Reyes
Profesor: Carlos González
'''
######################## LIBRERIAS ########################
import numpy as np
import matplotlib.image as mpi
import matplotlib.pyplot as mpp
######################## FUNCIONES ########################
# Retorna la imagen que se encuentra en la ruta especificada (en escala de grises!!).
#
# Entrada:
# ruta - string correspondiente a la ruta de la imagen
#
# Salida:
# img - arreglo que contiene los datos de la imagen normalizada
def leerImagen(ruta):
img = mpi.imread(ruta)
return img / 255
# Guarda la imagen que se encuentra en la ruta especificada, comprueba si es filtro
# o no para aplicar el cmap gris.
#
# Entrada:
# img - arreglo con los datos de la imagen
# ruta - string correspondiente a la ruta de la imagen
# titulo - string con el nombre de la imagen
# filtro - booleano que representa si la imagen es filtro o espectro
def guardarImagen(img, ruta, titulo, filtro):
if filtro:
mpp.imshow(img, cmap="gray",vmin=0, vmax=1)
else:
mpp.imshow(img)
mpp.title(titulo)
img = mpp.gcf()
img.savefig(ruta, dpi=100)
# Muestra la imagen que se encuentra en la ruta especificada, comprueba si es filtro
# o no para aplicar el cmap gris.
#
# Entrada:
# img - arreglo con los datos de la imagen
# titulo - string con el nombre de la imagen
# filtro - booleano que representa si la imagen es filtro o espectro
def visualizarImagen(img, titulo, filtro):
if filtro:
mpp.imshow(img, cmap="gray",vmin=0, vmax=1)
else:
mpp.imshow(img)
mpp.title(titulo)
mpp.show()
# Crea una matriz igual a la matriz imagen, pero rodeada de un contorno de ceros del tamaño necesario para aplicar la convolución.
#
# Entradas
# imagen - arreglo que contiene los datos de la imagen
# kernel - arreglo que contiene los datos del filtro
#
# Salidas
# matriz0 - matriz llena de ceros
def matrizCero(imagen, kernel):
# MC -> matriz ceros
NFilasKernel, NColuKernel = kernel.shape
NFilasImg, NColuImg = imagen.shape
PosFilaMC = NFilasKernel - 1
PosColuMC = NColuKernel - 1
PosFilaImg = 0
PosColuImg = 0
matriz0 = np.zeros((NFilasImg + 2 * PosFilaMC, NColuImg + 2 * PosColuMC))
for i in range(PosFilaMC, PosFilaMC + NFilasImg):
for j in range(PosColuMC, PosColuMC + NColuImg):
matriz0[i][j] = imagen[PosFilaImg][PosColuImg]
PosColuImg+=1
PosFilaImg += 1
PosColuImg = 0
return matriz0
# Aplica la convolución en 2 dimensiones entre la imagen y el kernel.
#
# Entrada:
# imagen - arreglo que contiene los datos de la imagen
# kernel - arreglo que contiene los datos del filtro
#
# Salida:
# convolucion - Matriz imagen filtrada
def convolucion2D(imagen, kernel):
convolucion = []
# Matriz e indicadores
matriz0 = matrizCero(imagen, kernel)
NFilasMC, NColuMC = matriz0.shape
# Kernel e indicadores
kernel = np.flipud(np.fliplr(kernel))
NFilasKernel, NColuImg = kernel.shape
# Iteradores #
iterFilas = NFilasMC - NFilasKernel + 1
iterColumnas = NColuMC - NColuImg + 1
PosFilaConvolucion = 0
for fila in range(iterFilas):
convolucion.append([]) #se inicia la fila vacia
for col in range(iterColumnas):
suma = 0 #se reinicia la cuenta en cada columna
for fk in range(NFilasKernel):
for ci in range(NColuImg):
suma += kernel[fk][ci] * matriz0[fila + fk][col + ci]
convolucion[PosFilaConvolucion].append(suma)
PosFilaConvolucion += 1
return convolucion
# Calcula la transformada de Fourier en 2D para una imagen dada.
#
# Entrada:
# imagen - arreglo que contiene los datos de la imagen
#
# Salida:
# Matriz del esprectro de Fourier - arreglo que contiene los datos de la transformada de Fourier de la imagen
def fourier(imagen):
np.seterr(divide = 'ignore') #Configuración necesaria (recomendacion de internet)
# Transformada de Fourier #
tf = np.fft.fft2(imagen)
# Shift de zero a la Transformada #
tfs = np.fft.fftshift(tf)
# Retorno del valor normalizado positivo #
return 20 * np.log(np.abs(tfs))
######################## EJECUCION PROGRAMA ########################
## Creacion de filtros ##
filtroBordes = np.array([[1,2,0,-2,-1],[1,2,0,-2,-1],[1,2,0,-2,-1],[1,2,0,-2,-1],[1,2,0,-2,-1]]).astype('float') # Kernel Bordes
filtroSuavizado = np.array([[1,4,6,4,1],[4,16,24,16,4],[6,24,36,24,6],[4,16,24,16,4],[1,4,6,4,1]]).astype('float') * (1/256) # Kernel Gauss
###### Testing ######
filtroEmbosy = np.array([[-2,-1,0],[-1,1,1],[0,1,2]]).astype('float') # Kernel Embosy para testing
print('... Inicio Testing ...')
print('* Las imagenes de testing no son almacenadas *')
test = leerImagen('img-test.gif')
visualizarImagen(test,'Imagen de Testing',True)
print('Testeando Convolucion 2D con kernel 3x3 "Ebmosy"')
testConv = convolucion2D(test, filtroEmbosy)
visualizarImagen(testConv,'Test Convolucion',True)
print('Testeando kernel Filtro Suavizado')
testFS = convolucion2D(test, filtroSuavizado)
visualizarImagen(testFS,'Test Suavizada',True)
print('Testeando kernel Filtro de Bordes')
testFB = convolucion2D(test, filtroBordes)
visualizarImagen(testFB,'Test Bordes',True)
print('... Fin Testing ...')
######################
## Lectura de imagen ##
imagen = leerImagen('leena512.bmp')
## Mapeo de imagen original ##
visualizarImagen(imagen,'Imagen Original',True)
###### Filtros ######
## Aplicacion de filtro de suavizado gaussiano ##
imgFS = convolucion2D(imagen, filtroSuavizado)
## Aplicacion de filtro detector de bordes ##
imgFB = convolucion2D(imagen, filtroBordes)
## Mapeo de imagen filtrada suavizado ##
visualizarImagen(imgFS,'Imagen Suavizada',True)
guardarImagen(imgFS,'./Img_Suavizada.png','Imagen Suavizada',True)
## Mapeo de imagen filtrada bordes ##
visualizarImagen(imgFB,'Imagen Bordes Detectados',True)
guardarImagen(imgFB,'./Img_Bordes.png','Imagen Bordes Detectados',True)
###### Transformadas de Fourier ######
## Aplicacion transformada de fourier imagen original ##
espectroImg = fourier(imagen)
## Mapeo fourier imagen original ##
visualizarImagen(espectroImg,'Espectro Fourier Imagen Original',False)
guardarImagen(espectroImg,'./Fourier_Original.png','Espectro Fourier Imagen Original',False)
## Aplicacion transformada de fourier imagen filtrada suavizado ##
espectroImgFS = fourier(imgFS)
## Mapeo fourier imagen filtrada suavizado ##
visualizarImagen(espectroImgFS,'Espectro Fourier Imagen Suavizada',False)
guardarImagen(espectroImgFS,'./Fourier_Suavizada.png','Espectro Fourier Imagen Suavizada',False)
## Aplicacion transformada de fourier imagen filtrada bordes ##
espectroImgFB = fourier(imgFB)
## Mapeo fourier imagen filtrada bordes ##
visualizarImagen(espectroImgFB,'Espectro Fourier Imagen Bordes Detectados',False)
guardarImagen(espectroImgFB,'./Fourier_Bordes.png','Espectro Fourier Imagen Bordes Detectados',False)