1
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.
Práctica VII. Restauración.
Duarte García Jesús, Nava Vargas Cathia Michelle.
 𝐻(𝑢, 𝑣) =
Resumen—Para tener un mejor manejo de los puntos de la
practica los agrupamos dependiendo de la relación que había
entre ellos, resultándonos la división de la práctica en cuatro
fases. Las primeras dos etapas consistían en corromper una
imagen en buen estado, aplicándole ruido, Gaussiano para la
primera, y sal y pimienta para la segunda. En cada una de las
etapas usamos un filtro; para la primera usamos un filtrado
espacial (promedio aritmético, promedio geométrico, promedio
armónico, mediana), en la segunda fase hicimos uso de filtros
Butterworth pasa-altas, y pasa-bajas, para la tercera etapa
implementamos el filtro Sobel y en la etapa final utilizamos el
filtro Wiener. Cabe mencionar que para el procesamiento de la
imagen en cada una de las facetas utilizamos el programa de
MATLAB con sus respectivos comandos.
I. INTRODUCCIÓN
STE documento presenta lo realizado, los procedimientos
Eutilizados, resultados obtenidos y conclusiones a las que
llego el equipo, durante la realización de la séptima practica.
En esta práctica utilizamos el programa de MATLAB y sus
respectivos comandos para evitar la realización de procesos
muy largos y laboriosos, aplicamos conocimientos vistos en
clase referente a filtrado espacial y en frecuencia. El objetivo
primario de realizar un filtrado a una imagen es disminuir el
ruido que la corrompe, entendemos el concepto de ruido como
información no deseada que contamina la imagen. Existen dos
tipos de filtrados: espacial y frecuencial. El filtrado espacial
utiliza vecindades de pixeles, esto quiere decir que se toma un
pixel como centro y los 8 pixeles que los rodean para,
mediante ecuaciones que sirven como filtros, generar un
nuevo valor que nos da como resultado nuestra imagen
filtrada. Los filtros en el dominio de la frecuencia trabajan
únicamente en el dominio de Fourier por lo cual es necesario
aplicar una transformación discreta de Fourier a nuestra
imagen a filtrar y, posteriormente, manipular las frecuencias
mediante distintas ecuaciones para conseguir nuestro filtrado.
𝑓̂(𝑥, 𝑦) =
1
∑(𝑠,𝑡)∈𝑆𝑥𝑦 𝑔(𝑠, 𝑡) (1)
𝑚𝑛
1
𝑓̂(𝑥, 𝑦) = [∏(𝑠,𝑡)𝜖𝑆𝑥𝑦 𝑔(𝑠, 𝑡)]
𝑚𝑛
(2)
𝑚𝑛
𝑓̂(𝑥, 𝑦) = 1 (3)
∑(𝑠,𝑡)∈𝑆𝑥𝑦
𝑔(𝑠,𝑡)
1 comandos, una vez hecho esto procedimos a leer la imagen
𝐻(𝑢, 𝑣) = 𝐷(𝑢,𝑣) 2𝑛
(4)
1+[ ]
𝐷𝑜
1
𝐻(𝑢, 𝑣) = 𝐷𝑜 2𝑛
(5)
1+[ ]
𝐷(𝑢,𝑣)
08 de Mayo del 2017
𝑇
sin[𝜋(𝑢𝑎 + 𝑣𝑏)] 𝑒 −𝑗𝜋(𝑢𝑎+𝑣𝑏) (6)
𝜋(𝑢𝑎+𝑣𝑏)
𝑇
𝑃1 = (7)
𝜋(𝑢𝑎+𝑣𝑏)
𝑃2 = sin[𝜋(𝑢𝑎 + 𝑣𝑏)] (8)
𝑃3 = 𝑒 −𝑗𝜋(𝑢𝑎+𝑣𝑏) (9)
1 |𝐻(𝑢,𝑣)|2
̂𝐹 (𝑢, 𝑣) = [ ] 𝐺(𝑢, 𝑣) (10)
𝐻(𝑢,𝑣) |𝐻(𝑢,𝑣)|2 +𝐾
II. DESARROLLO
La practica la dividimos en cuatro etapas, para tener un
mejor manejo de cada uno de los puntos requeridos, cada
etapa contiene los puntos que se relacionan entre ellos por
medio de las imágenes de entrada como resultantes.
En la primera etapa a una imagen en buen estado le
agregamos un ruido aditivo Gaussiano, utilizando un
comando, a esta imagen resultante le colocamos un filtrado
espacial implementando tres filtros (aritmético, geométrico,
armónico, y mediana) .
En nuestra segunda fase igualmente corrompimos y
filtramos una imagen en buen estado, utilizamos el ruido sal y
pimienta, y para el filtrado fue un filtro Butterworth pasa-
bajas. En esta parte de la práctica también hicimos uso del
filtro Butterworth pasa-altas, sin embargo se aplico a la
imagen en buen estado.
Para la tercera etapa obtuvimos los bordes de una imagen
por medio del filtro Sobel, cabe mencionar que esto lo
realizamos de forma manual y usando comandos.
En la etapa final hicimos uso de las imágenes resultantes, de
los ruidos Gaussiano, y sal y pimienta, además de nuestra
imagen en buen estado utilizada en toda la práctica. A todas
las imágenes les aplicamos un filtro Wiener de forma manual.
III. MÉTODOS Y CÁLCULOS
Como ya se menciono en el transcurso del reporte, la
práctica se dividió por etapas, en cada una de ellas realizamos
un código diferente en MATLAB, que se muestran
respectivamente en los apéndices. Absolutamente en las
cuatro etapas de la práctica, primero tuvimos que cerrar todas
las ventanas que posiblemente tuviéramos abiertas, esto con la
finalidad de no crear confusiones entre las figuras que se iban
desplegando y que no tuviéramos conflictos en el uso de los
con la que se estaba trabajando, después la pasamos a un
formato doble y por último la imagen resultante en este
formato la normalizamos dividiéndola entre el número de
niveles de gris que se estaba manejando.
En nuestra primera etapa, creamos una matriz del mismo
tamaño que la imagen original, la cual estará llena con puros
ceros. Para añadir el ruido aditivo Gaussiano a la imagen

Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.
utilizamos el comando “imnoise”, el filtro “gaussian” y los
valores de “m” igual a cero y “σ” igual a cero punto cero
nueve, para crear el filtro promedio aritmético utilizamos [1],
haciendo uso una matriz de tres por tres llena de unos,
teniendo hecho esto, se aplica el filtro a nuestra imagen con
ruido. Para el filtro promedio geométrico y armónico, creamos
una matriz de tres por tres, igualmente llena de unos,
recorremos la imagen en cada pixel en el que pueda actuar la
máscara en tu totalidad, usando dos ciclos for anidados,,
también tuvimos que crear nueve variables que representan
nuestra vecindad de ocho vecinos para cada pixel, enseguida
cada elemento de nuestra matriz del filtro se multiplicara por
su correspondiente en la vecindad, finalizando los ciclos,
aplicamos [2] para el filtro promedio geométrico, y [3] para el
filtro promedio armónico. Por último en el filtro mediana,
creamos una matriz de tres por tres llena de unos, y una matriz
vacía donde guardaremos nuestra imagen filtrada, al igual que
en los filtros pasados, recorremos la matriz de la imagen
original en busca de los pixeles en los que se les pueda aplicar
el filtro en su totalidad, cabe mencionar que si es nuestro
primer filtro, utilizamos un vector de nueve posiciones, y en
cada una guardamos el resultado de la multiplicación de cada
una de las posiciones de la matriz llena de unos con la matriz
que tiene el ruido igualmente en diferentes posiciones, una vez
que llenamos nuestro vector buscamos el valor de la mediana.
En caso contrario de que no sea nuestro primer filtro, entonces
tomamos los resultados anteriores a la matriz, es decir
tomaremos la imagen filtrada en lugar de utilizar la imagen
corrompida con el ruido, igualmente los resultados se guardan
en un vector de nueve posiciones y se busca la mediana. Para
finalizar utilizamos un switch que tuvo el objetivo de guardar
cada iteración del filtro mediana.
En la segunda fase corrompimos una imagen en buen estado
con el ruido sal y pimienta utilizando el comando “imnoise”
aplicado a la imagen original junto con el filtro “salt &
pepper”, utilizando el valor de cero punto uno, a esta imagen
le aplicamos la transformada discreta de Fourier utilizando el
comando “fft2”y la centramos con el comando “fftshift”, para
el centro de nuestra imagen tuvimos que obtener los valores
centrales, para esto dividimos el numero de columnas y
renglones entre dos, con ayuda de dos ciclos for anidados que
tiene como condición de paro el tamaño de nuestra matriz
original, en este ciclo creamos una matriz con la distancia de
cada pixel, y dos matrices mas, una para el filtro pasa-bajas
utilizando [4], y otra para el filtro pasa-altas utilizando [5],
una vez teniendo las matrices de los filtros, realizamos la
convolución con la matriz de la imagen con ruido, en dominio
de Fourier, realizado esto, por ultimo aplicamos la inversa de
Fourier con el comando “ifft2” para recuperar la imagen.
Para la tercera fase realizamos la obtención de los bordes de
forma manual y mediante comandos. De forma manual
tuvimos que crear dos matrices para poder detectar bordes en
el eje “x” y en el eje “y”, enseguida aplicamos un filtro con el
comando “imfilter” a la matriz de la imagen original y a la
matriz del eje “x”, luego realizamos esto mismo pero
cambiando la matriz del eje “x” por la matriz de eje “y”, por
ultimo combinamos las imágenes resultantes, para esto
elevamos cada una de las matrices al cuadrado, las sumamos y
sacamos raíz al resultado de esta sumatoria. Para obtener los
bordes mediante comandos, utilizamos el comando “edge” el
2
cual se aplico a la imagen original y también se hizo uso
directo del filtro “sobel”
Para la última etapa obtuvimos inicialmente dos imágenes,
una que contenía un ruido impulso o sal y pimienta, y otra que
con ruido aditivo Gaussiano, en ambos filtros usamos el
comando “imnoise”; para el ruido aditivo Gaussiano usamos
“m” igual a cero y “σ” igual a cero punto uno, igualmente para
el ruido sal y pimienta el valor utilizado fue de cero punto uno.
Para la creación del filtro, a la imagen original le aplicamos la
transformada discreta de Fourier mediante el comando “fft2” y
la centramos con el comando “fftshift”, enseguida declaramos
las constantes de [6], a=1, b=a, T=1, y K=400. Creamos una
matriz del mismo tamaño que nuestra imagen original y
obtuvimos H usando [6], para esto dividimos la formula, y
utilizamos auxiliares, el primero tenía el resultado de [7], el
segundo guardaba el resultado de [8] y por último el tercer
auxiliar contenía el resultado de [9], teniendo los tres
auxiliares realizamos la multiplicación de ellos y a este
resultado le sumamos 0.00001. A nuestra matriz H le
aplicamos con los mismos comandos ya mencionados, la
transformada discreta de Fourier y la centramos; con dos
ciclos for anidados aplicamos [10], generando una nueva
matriz, a esta ultima matriz igualmente con comandos le
colocamos la transformada inversa de Fourier y la centramos,
utilizando los comandos de “ifftshift” y “ifft2”. Realizamos
este mismo procedimiento pero aplicándolo a nuestras
imágenes con ruido.
IV. RESULTADOS
A. Etapa Uno
La Fig. 1. Nos muestra la imagen original con la que se
trabajo durante toda la práctica, podemos notar que es una
imagen en buen estado, la Fig. 2 nos presenta la Fig. 1.
implementándole ruido aditivo Gaussiano, la Fig. 3. es la Fig.
2 con el filtro promedio aritmético, mientras que la Fig. 4 es la
Fig. 2 con un filtro promedio geométrico. El filtro promedio
armónico implementado en la Fig. 2, se presenta en la Fig. 5,
de la Fig. 6 a la Fig. 10, presentamos las imágenes resultantes
aplicando diferentes medianas.
 3
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

Fig. 1. Imagen en buen estado.

Fig. 5. Filtro promedio armónico.

Fig. 2. Imagen con presencia de ruido aditivo Gaussiano.

Fig. 6. Filtro primera mediana.

Fig. 3. Filtro promedio aritmético.

Fig. 7. Filtro segunda mediana.

Fig. 4. Filtro promedio geométrico.

 4
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

B. Segunda Etapa
La Fig. 11 nos muestra la imagen resultante de la Fig. 1.
implementándole ruido sal y pimienta, las siguientes dos
Figuras nos muestran la Fig. 11. con los filtros Butterworth, la
Fig. 12 tiene el filtro pasa-bajas, mientras que la Fig. 13
contiene implementado el filtro pasa-altas.

Fig. 8. Filtro tercera mediana.

Fig. 11. Imagen con ruido sal y pimienta.

Fig. 9. Filtro cuarta mediana.

Fig. 12. Imagen con un filtro Butterworth pasa-bajas.

Fig. 10. Filtro quinta mediana.

 5
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

Fig. 13. Imagen con un filtro Butterworth pasa-altas. Fig. 15. Imagen con el filtro Sobel utilizando comandos.

C. Tercera Etapa D. Cuarta Etapa

Las siguientes dos figuras nos muestran los resultados de En esta etapa utilizamos la Fig. 1, la Fig. 11 y la Fig. 16,
la implementación del filtro “Sobel” a la Fig. 1, para la para implementarles un filtro Wiener, presentando en la
obtención de bordes, de forma manual y mediante el uso de figuras restantes los resultados obtenidos.
comandos.

Fig. 16. Imagen con ruido aditivo Gaussiano.

Fig. 14. Imagen con el filtro Sobel de forma manual.

Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.
Fig. 17. Imagen en buen estado implementándole un filtro
Wiener.
Fig. 18. Imagen resultante de aplicar un filtro Wiener a una
imagen con ruido aditivo Gaussiano.
Fig. 19. Imagen resultante de aplicar un filtro Wiener a una
imagen con ruido sal y pimienta.
6
V. DISCUSIÓN Y CONCLUSIONES
Con respecto a nuestros resultados obtenidos en cada etapa,
logramos observar diferentes cosas con respecto al filtrado
espacial y frecuencial. En nuestra primera etapa, podemos
notar con bastante claridad la diferencia entre una imagen en
perfecto estado con esta misma imagen pero corrompida con
ruido, la calidad disminuye en gran medida, haciendo que la
imagen sea inadecuada para su aplicación, sin embargo al
momento de colocarle los diferentes filtros nos percatamos
que la calidad de la imagen en lugar de mejorar, empeora
notablemente, en especial con los filtros, mediana y promedio
armónico, fue interesante ver como conforme cambiábamos el
valor de la mediana, la imagen se volvía cada vez mas borrosa,
además cabe mencionar que el filtro promedio geométrico y el
filtro promedio aritmético, arrojaron un resultado bastante
similar, incluso se puede decir que la diferencia entre ambos
es casi nula, por ultimo nos dimos cuenta que si el valor
utilizado al momento de aplicar el ruido gaussiano es más
próximo a cero, el ruido es menos a comparación de si se usa
un valor muy aproximada a cero punto uno.
En la segunda etapa observamos la misma imagen inicial de
la etapa uno pero esta vez implementándole un ruido sal y
pimienta, notamos que la calidad de la imagen disminuye pero
en menor medida a comparación que la imagen con el ruido
aditivo gaussiano, en esta etapa hicimos uso de los filtros
Butterworth, pasa-bajas y pasa-altas, notando que el primero
se enfoca mas en las formas pero no a gran detalle, mientras
que el segundo tiene un enfoque a contornos, sin embargo
ninguno de los dos filtros es cien por ciento adecuado para
mejorar la calidad de la imagen después de aplicarle ruido.
En la tercera etapa realizamos una obtención de bordes de
forma manual y utilizando comandos, en prácticas anteriores
nos percatábamos que al realizarlas por ambas formas, la
diferencia en los resultados era prácticamente nula, sin
embargo en esta ocasión la diferencia entre ambos resultados
es bastante notoria, los bordes mediante el uso de comandos
resultan ser muy pronunciados, mientras que de formar
manual se puede distinguir un poco más la forma de la figura
de la imagen original, sin embargo los bordes al contrario del
uso de comandos resultan ser un tanto borrosos.
En la cuarta etapa, notamos que al aplicar este filtro en una
imagen con ruido gaussiano, y sal y pimienta, se logra el
objetivo de disminuirlo, sin embargo la calidad de la imagen
no es buena en lo absoluto, además de que el brillo en la
imagen aumenta un poco. En cuanto a aplicarlo a una imagen
en perfecto estado, como no lo necesita provoca un efecto
negativo en ella, iniciando porque la vuelve un tanto borrosa y
el brillo aumenta igualmente un poco.
 7
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

APÉNDICE I

ETAPA I

function [ FiltroGeom ] = untitled( input_args )

%UNTITLED Summary of this function goes here
% Detailed explanation goes here

%Leemos nuestra imagen con imread, la transformamos a una sola matriz en escala de grises con rgb2gray, le damos un formato
doble y la normalizamos
ImOr=double(rgb2gray(imread('rm_rodilla.jpg')))/255;
%Creamos una matriz del mismo tamaño pero en ceros.
FiltroGeom=ImOr*0;

% Filtro Promedio
%Creamos nuestra matriz que usaremos como filtro
FiltroPromedio=ones(3)/9;
%Mostramos nuestra imagen original con un plot
subplot(1,3,1), imshow(ImOr), title('Original');
%Le añadimos un ruido gaussiano a nuestra imagen
ImRuidoGauss=imnoise(ImOr,'gaussian',0,0.09);
%Mostramos la imagen corrompida en el mismo plot
subplot(1,3,2), imshow(ImRuidoGauss), title('Ruido Gaussiano m=0, varianza=0.09');
%Guardamos esta imagen corrompida
imwrite(ImRuidoGauss,'Imagen con Ruido Gaussiano.jpg','jpg');
%Aplicamos el filtro a la imagen corrompida
ImFiltroProm=conv2(ImRuidoGauss,FiltroPromedio,'full');
%Mostramos la imagen en nuestro Plot
figure(1), subplot(1,3,3), imshow(ImFiltroProm), title('Filtro Promedio');
%Guardamos nuestra imagen filtrada
imwrite(ImFiltroProm,'Imagen con Filtro Promedio.jpg','jpg');

%% Filtro Promedio Geométrico

%Creamos la matriz del filtro
m1=ones(3);
%Recorremos la imagen en cada pixel donde la máscara pueda actuar completamente.
for x=2:size(ImOr,1)-1;
for y=2:size(ImOr,2)-1;
%Creamos 9 variables representando nuestra vecindad de 8-vecinos de cada pixel con el pixel de esta vecindad. Cada elemento
de nuestra matriz del filtro se multiplicara por su correspondiente en la vecindad.
v1= m1(1,1)*ImRuidoGauss(x-1,y-1);
v2= m1(1,2)*ImRuidoGauss(x-1,y);
v3= m1(1,3)*ImRuidoGauss(x-1,y+1);
v4= m1(2,1)*ImRuidoGauss(x,y-1);
v5= m1(2,2)*ImRuidoGauss(x,y);
v6= m1(2,3)*ImRuidoGauss(x,y+1);
v7= m1(3,1)*ImRuidoGauss(x+1,y-1);
v8= m1(3,2)*ImRuidoGauss(x+1,y);
v9= m1(3,3)*ImRuidoGauss(x+1,y+1);
%Aplicamos la formula de un filtro geométrico, multiplicando todas las variables y dividiendo entre el numero de variables, en
este caso, 9.

FiltroGeom(x,y)=(v1*v2*v3*v4*v5*v6*v7*v8*v9).^(1/9);
end
end
r=2
%Mostramos la imagen en nuestro Plot
 8
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

figure (1), subplot(1,3,3), imshow(FiltroGeom), title('Filtro Geometrico');

%Guardamos nuestra imagen filtrada
imwrite(ImFiltroProm,'Imagen con Filtro Geometrico.jpg','jpg');

%% Filtro Promedio Armónico

%Creamos nuestra matriz del filtro
m1=ones(3);
%Creamos una matriz vacía para la nueva imagen filtrada
FiltroArmonico=FiltroGeom*0;
%Recorremos la matriz en todos los pixeles donde nuestro filtro puede ser
%aplicado en su totalidad.
for x=2:size(ImOr,1)-1;
for y=2:size(ImOr,2)-1;
%Creamos 9 variables representando nuestra vecindad de 8-vecinos de cada pixel con el pixel de esta vecindad. Cada elemento
de nuestra matriz del filtro se multiplicara por su correspondiente en la vecindad.
v1= m1(1,1)*ImRuidoGauss(x-1,y-1);
v2= m1(1,2)*ImRuidoGauss(x-1,y);
v3= m1(1,3)*ImRuidoGauss(x-1,y+1);
v4= m1(2,1)*ImRuidoGauss(x,y-1);
v5= m1(2,2)*ImRuidoGauss(x,y);
v6= m1(2,3)*ImRuidoGauss(x,y+1);
v7= m1(3,1)*ImRuidoGauss(x+1,y-1);
v8= m1(3,2)*ImRuidoGauss(x+1,y);
v9= m1(3,3)*ImRuidoGauss(x+1,y+1);
%Sumamos todos los inversos de nuestras variables
suma=(1/v1)+(1/v2)+(1/v3)+(1/v4)+(1/v5)+(1/v6)+(1/v7)+(1/v8)+(1/v9);
%Aplicamos la formula de nuestro filtro
FiltroArmonico(x,y)=(9)/suma;
end
end
%Guardamos nuestra imagen filtrada
imwrite(FiltroArmonico, 'Filtro Armonico.jpg', 'jpg');
%Mostramos la imagen en nuestro Plot
figure (1), subplot(1,3,3), imshow(FiltroGeom), title('Filtro Armonico');

%% Filtro Mediana
%Creamos la matriz de nuestro filtro
m1=ones(3);
%Creamos una matriz vacía donde guardaremos nuestra nueva imagen filtrada
FiltroMediana=FiltroGeom*0;
%Recorremos todos los pixeles donde nuestro filtro puede ser aplicado agregando un ciclo extra para cada iteración de nuestro
filtro Mediana
for z=1:5;
for x=2:size(ImOr,1)-1;
for y=2:size(ImOr,2)-1;
%Si es nuestro primer ciclo crearemos una matriz donde guardaremos los resultados nuevos
if z==1
v(1)= m1(1,1)*ImRuidoGauss(x-1,y-1);
v(2)= m1(1,2)*ImRuidoGauss(x-1,y);
v(3)= m1(1,3)*ImRuidoGauss(x-1,y+1);
v(4)= m1(2,1)*ImRuidoGauss(x,y-1);
v(5)= m1(2,2)*ImRuidoGauss(x,y);
v(6)= m1(2,3)*ImRuidoGauss(x,y+1);
v(7)= m1(3,1)*ImRuidoGauss(x+1,y-1);
v(8)= m1(3,2)*ImRuidoGauss(x+1,y);
v(9)= m1(3,3)*ImRuidoGauss(x+1,y+1);
%Se busca el valor de la mediana en nuestro vector
M=median(v);
%Se guarda
FiltroMediana(x,y)=M;
 9
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

%Si no es nuestro primer filtro simplemente iremos tomando los resultados anteriores a la matriz
else
%En lugar de utilizar la imagen corrompida, utilizamos la imagen filtrada anteriormente
v(1)= m1(1,1)*FiltroMediana(x-1,y-1);
v(2)= m1(1,2)*FiltroMediana(x-1,y);
v(3)= m1(1,3)*FiltroMediana(x-1,y+1);
v(4)= m1(2,1)*FiltroMediana(x,y-1);
v(5)= m1(2,2)*FiltroMediana(x,y);
v(6)= m1(2,3)*FiltroMediana(x,y+1);
v(7)= m1(3,1)*FiltroMediana(x+1,y-1);
v(8)= m1(3,2)*FiltroMediana(x+1,y);
v(9)= m1(3,3)*FiltroMediana(x+1,y+1);
%Se busca la mediana
M=median(v);
%Se guarda el valor
FiltroMediana(x,y)=M;
end
end
end
%Este switch tiene el objetivo de guardar cada iteración del filtro Mediana
switch z
case 1
Mediana1=FiltroMediana;
imwrite(Mediana1, 'Filtro Mediana1.jpg', 'jpg');
case 2
Mediana2=FiltroMediana;
imwrite(Mediana2, 'Filtro Mediana2.jpg', 'jpg');
case 3
Mediana3=FiltroMediana;
imwrite(Mediana3, 'Filtro Mediana3.jpg', 'jpg');
case 4
Mediana4=FiltroMediana;
imwrite(Mediana4, 'Filtro Mediana4.jpg', 'jpg');
case 5
Mediana5=FiltroMediana;
imwrite(Mediana5, 'Filtro Mediana5.jpg', 'jpg');
end
end
%Mostramos la imagen final en nuestro Plot
figure (1), subplot(1,3,3), imshow(FiltroMediana), title('Filtro Mediana');
end
 10
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

APÉNDICE II

ETAPA II

function [ ] = untitled2( n, D0 )
%UNTITLED2 Summary of this function goes here
% Detailed explanation goes here

%Leemos nuestra imagen dándole el tratamiento necesario para poder trabajarla

ImOr=double(rgb2gray(imread('rm_rodilla.jpg')))/255;
%Obtenemos el tama?o de nuestra imagen en dos variables
[M,N]=size(ImOr);
%Corrompemos la imagen con ruido impulso
ImagenSalPimienta=imnoise(ImOr, 'salt & pepper', .1);
%Mostramos la imagen original y la imagen corrompida en un Plot
figure (1), subplot(1,2,1), imshow(ImOr), title('Imagen Original');
figure (2), subplot(1,2,1), imshow(ImagenSalPimienta), title('Imagen sal Y pimienta');
%Calculamos la transformada de Fourier de nuestra imagen corrompida y la centramos
FourierSyP=fft2(ImagenSalPimienta);
FourierCentradaSyP=fftshift(FourierSyP);
%Lo mismo haremos con nuestra imagen original
Fourier=fft2(ImOr);
FourierCentrada=fftshift(Fourier);
%Obtenemos el valor de u y v para el centro de nuestra imagen
u=M/2; v=N/2;
%Creamos un ciclo del tamaño de nuestra imagen
for x=1:M
for y=1:N
%Creamos una matriz con la distancia de cada pixel
D(x,y)=sqrt((x-u).^2+(y-v).^2);
%Creamos nuestra matriz del filtro Pasa-Bajas
PB(x,y)=(1/(1+((D(x,y)/D0).^(2*n))));
%Creamos nuestra matriz del filtro Pasa-Altas
PA(x,y)=(1/(1+((D0/D(x,y)).^(2*n))));
end
end
%Aplicamos la convolución a nuestra imagen corrompida en el dominio de Fourier
ImagenPasaBajas=PB.*FourierCentradaSyP;
%Aplicamos la convolución a nuestra imagen original en el dominio de Fourier
ImagenPasaAltas=PA.*FourierCentrada;
%Obtenemos las inversas de Fourier para recuperar la imagen
ImagenPasaBajas=ifft2(ImagenPasaBajas);
ImagenPasaAltas=ifft2(ImagenPasaAltas);
figure (1), subplot(1,2,2), imshow(real(uint8(ImagenPasaAltas*255))), title('Imagen Con Pasa Altas');
figure (2), subplot(1,2,2), imshow(real(uint8(ImagenPasaBajas*255))), title('Imagen con Pasa Bajas');
%Guardamos nuestras imágenes en la carpeta
imwrite(ImagenPasaBajas, 'Imagen Pasa Bajas.jpg', 'jpg');
imwrite(ImagenPasaAltas, 'Imagen Pasa Altas.jpg', 'jpg');
end
 11
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

APÉNDICE III

ETAPA III

function [ output_args ] = untitled3( input_args )

%UNTITLED3 Summary of this function goes here
% Detailed explanation goes here
%Leemos nuestra imagen con el proceso necesario para manipularla
ImOr=double(rgb2gray(imread('rm_rodilla.jpg')))/255;
%Creamos nuestras dos matrices para detectar bordes en el eje x y en el eje y
Tempx=[-1,0,1;-2,0,2;-1,0,1]/4;
Tempy=[-1,-2,-1;0,0,0;1,2,1]/4;
%Aplicamos nuestros filtros y guardamos cada uno de ellos
Gx=imfilter(ImOr,Tempx);
Gy=imfilter(ImOr,Tempy);
%Combinamos ambas imágenes
G=sqrt((Gx.^2)+(Gy.^2));
%Mostramos el resultado
imshow((G)), title('Deteccion de bordes Manual');
%Guardamos nuestra imagen
imwrite(G, 'Deteccion de bordes manual.jpg','jpg');
%Aplicamos nuestro comando para detectar bordes y guardamos en una variable
B=edge(ImOr,'sobel');
%Mostramos el resultado
figure (2), imshow(B), title('Deteccion de bordes Comando');
%Guardamos nuestra imagen de comando
imwrite(B, 'Deteccion de bordes comando.jpg','jpg')
end
 12
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

APÉNDICE IV

ETAPA IV

function [ ] = untitled4( input_args )

%UNTITLED4 Summary of this function goes here
% Detailed explanation goes here
%Leemos nuestra imagen con el debido proceso para poder manipularla
ImOr=double(rgb2gray(imread('rm_rodilla.jpg')))/255;
%Obtenemos el tama?o de la imagen en dos variables
[M,N]=size(ImOr);
%Obtenemos una imagen corrompida con ruido impulso
ImagenSalPimienta=imnoise(ImOr, 'salt & pepper', .1);
%Obtenemos una imagen corrompida con ruido gaussiano
ImRuidoGauss=imnoise(ImOr,'gaussian',0,0.1);
%Aplicamos Fourier a nuestra imagen original y la centramos
Fourier=fft2(ImOr);
FourierCentrada=fftshift(Fourier);
%Declaramos nuestras constantes
a=0.1;
b=a;
T=1;
K=400;
%Creamos una matriz del mismo tama?o de nuestra imagen con nuestra fórmula para obtener H
for x=1:M
for y=1:N
aux1=T/(pi*(x*a+b*y));
aux2=sin(pi*(a*x+y*b));
aux3=exp((-y)*pi*(a*x+y*b));
H(x,y)=(aux1*aux2*aux3)+.00001;
end
end
%Aplicamos Fourier a esa matriz y la centramos
H=fft2(H);
H=fftshift(H);
%Creamos otro ciclo para aplicar nuestra formula del Filtro de Wiener y obtener así una imagen
for x=1:M
for y=1:N
aux4=1/H(x,y);
complex=conj(H(x,y));
cuad=abs(H(x,y)).^2;
aux5=(cuad)/((cuad)+K);
aux6=FourierCentrada(x,y);
Fp(x,y)=aux4*aux5*aux6;
end
end
%Aplicamos una inversa de Fourier de esta ultima matriz.
Fp=ifftshift(Fp);
Fp=ifft2(Fp);

%Mostramos nuestras imagenes

figure(1), imshow(real((Fp*255))), title('Filtro Wiener');
figure(2), imshow(real((ImOr))), title('Imagen Original');
%Guardamos nuestras imagenes
imwrite(real((Fp*255)),'Filtro Wiener.jpg','jpg');
imwrite(real((ImOr)),'Imagen Original.jpg','jpg');
%Aplicamos Fourier a nuestra imagen con ruido impulso y la centramos
Fourier=fft2(ImagenSalPimienta);
 13
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

FourierCentrada=fftshift(Fourier);
%Creamos una matriz del mismo tama?o de nuestra imagen con nuestra fórmula para obtener H
for x=1:M
for y=1:N
aux1=T/(pi*(x*a+b*y));
aux2=sin(pi*(a*x+y*b));
aux3=exp((-y)*pi*(a*x+y*b));
H(x,y)=(aux1*aux2*aux3)+.00001;
end
end
%Aplicamos Fourier a esa matriz y la centramos
H=fft2(H);
H=fftshift(H);
%Creamos otro ciclo para aplicar nuestra formula del Filtro de Wiener y obtener así una imagen
for x=1:M
for y=1:N
aux4=1/H(x,y);
complex=conj(H(x,y));
cuad=abs(H(x,y)).^2;
aux5=(cuad)/((cuad)+K);
aux6=FourierCentrada(x,y);
Fp(x,y)=aux4*aux5*aux6;
end
end
%Aplicamos una inversa de Fourier de esta ultima matriz.
Fp=ifftshift(Fp);
Fp=ifft2(Fp);
%Mostramos nuestras imagenes
figure(1), imshow(real((Fp*255))), title('Filtro Wiener');
figure(2), imshow(real((ImagenSalPimienta))), title('Imagen Sal y Pimienta');
%Guardamos nuestras imagenes
imwrite(real((Fp*255)),'Filtro Wiener Sal y Pimienta.jpg','jpg');
imwrite(real((ImagenSalPimienta)),'Imagen Sal y Pimienta.jpg','jpg');
%Aplicamos Fourier a nuestra imagen con ruido impulso y la centramos
Fourier=fft2(ImRuidoGauss);
FourierCentrada=fftshift(Fourier);
%Creamos una matriz del mismo tama?o de nuestra imagen con nuestra fórmula para obtener H
for x=1:M
for y=1:N
aux1=T/(pi*(x*a+b*y));
aux2=sin(pi*(a*x+y*b));
aux3=exp((-y)*pi*(a*x+y*b));
H(x,y)=(aux1*aux2*aux3)+.00001;
end
end
%Aplicamos Fourier a esa matriz y la centramos
H=fft2(H);
H=fftshift(H);
%Creamos otro ciclo para aplicar nuestra formula del Filtro de Wiener y obtener así una imagen
for x=1:M
for y=1:N
aux4=1/H(x,y);
complex=conj(H(x,y));
cuad=abs(H(x,y)).^2;
aux5=(cuad)/((cuad)+K);
aux6=FourierCentrada(x,y);
Fp(x,y)=aux4*aux5*aux6;
end
end
%Aplicamos una inversa de Fourier de esta ultima matriz.
 14
Universidad Autónoma del Estado de México, Facultad de Medicina, Sexto Semestre.

Fp=ifftshift(Fp);
Fp=ifft2(Fp);
%Mostramos nuestras imagenes
figure(1), imshow(real((Fp*255))), title('Filtro Wiener');
figure(2), imshow(real((ImRuidoGauss))), title('Imagen Ruido Gauss');
%Guardamos nuestras imagenes
imwrite(real((Fp*255)),'Filtro Wiener Ruido Gaussiano.jpg','jpg');
imwrite(real((ImRuidoGauss)),'Imagen Ruido Gaussiano.jpg','jpg');
end