UNIVERSIDAD NACIONAL DEL CENTRO DEL PERU

FACULTAD DE INGENIERIA DE SISTEMAS

ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS

CUESTIONARIO RESUELTO DE MATEMATICA AVANZADA

ESTUDIANTE: LAZO REYES JOHANSY

QUIJADA ALDANA JENNYFER

CICLO: IV SEMESTRE

HUANCAYO, 9 DE NOVIEMBRE DE 2018

1. Procesamiento Digital de Imágenes con Matlab

En esta serie de prácticas vamos a ilustrar la aplicación al procesamiento digital de

imágenes en Matlab de varios métodos numéricos explicados en clase de teoría

En esta práctica introducimos algunos de los aspectos fundamentales de la

representación y manipulación de imágenes con Matlab.

2. Leer una Imagen

% Imagen
% Cuarto semestre
clear all;
clf;
clc;
J = imread('perrito.jpg');
figure(1); imshow(J)
I = rgb2gray(J);
figure(2);imshow(I);title('Original Image');
text(size(I,2),size(I,1)+15, ...
'logo de la
UNCP','FontSize',7,'HorizontalAlignment','right');
La imagen a leer debe encontrarse en la carpeta de trabajo de Matlab. Los
formatos de imagen soportados por Matlab son: TIFF, JPEG, GIF, BMP, PNG,
XWD.
Una imagen de color RGB se representa por tres matrices bidimensionales,
correspondientes a los planos R, G y B. Para obtener los planos RGB se ejecutan
los comandos:

%Separación de la figura segun el formato RGB.

J_R=J(:,:,1);
J_G=J(:,:,2);
J_B=J(:,:,3);
figure(3); imshow(J_R);
figure(4); imshow(J_G);
figure(5); imshow(J_B);
3. Lectura de un pixel de una imagen.

% Visualización del pixel.

p = impixel(J,20,18)

figure(7);imshow(p)
El tipo de dato matriz, que contendrá una imagen puede ser de varios tipos (según
el tipo de dato de cada pixel):
- double: Doble precisión, números en punto flotante que varían en un rango
aproximado de -10308 a 10308 (8 bytes por elemento)
 uint8: Enteros de 8 bits en el rango de [0,255] (1 byte por elemento)
 uint16: Enteros de 16 bits en el rango de [0, 65535] (2 bytes por elemento)
 uint32: Enteros de 32 bits en el rango de [0, 4294967295] (4 bytes por
elemento)
 int8: Enteros de 8 bits en el rango de [-128, 127] (1 byte por elemento)
 int16: Enteros de 16 bits en el rango de [-32768, 32767] (2 bytes por
elemento)
 int32: Enteros de 32 bits en el rango de [-2147483648,2147483647] (4
bytes por elemento)
 logical: Los valores son 0 ó 1 (1 bit por elemento)
Conversión entre tipos de datos: Para ciertas operaciones es necesario
convertir una imagen de su tipo original a otro tipo de imagen que facilite su
procesamiento. Algunos métodos:

Formato de lectura de imagen en escala de grises.

%Formato de lectura de imagen en escala de grises.

I = rgb2gray(J);
figure(2);imshow(I);title('Original Image');
text(size(I,2),size(I,1)+15,'logo de la frutas',
'FontSize',7,'HorizontalAlignment','right');

Algunos comandos que pueden utilizarse para determinar el tipo de imagen con
que se está trabajando:

%Cortar una Imagen

p=imcrop(J,[60 40 190 190]);
figure(6);imshow(p);
%p1=imcrop(J)

% Utlizacion de ventanas
subplot (2,1,1)
imshow(J)
subplot(2,1,2)
imshow(p)

4. Tranformaciones de intensidad
La sintaxis para aplicar una transformación de intensidad a una imagen f es:
>> g = imadjust (f, [low_in high_in], [low_out high_out])
Aplica los valores de intensidad de la imagen f (uint8, uint16 o doublé) que están
en el intervalo [low_in high_in] en valores del intervalo, [low_out high_out]
(considerando valores entre 0 y 1).
Transformación gamma:
>> g = imadjust (f, [low_in high_in], [low_out high_out], gamma)
Por ejemplo:

% Transformación de imagenes
%g = imadjust (f, [low_in high_in], [low_out high_out],
gamma)
figure(9)
g = imadjust (J, [0 1], [1 0], 1.2);% gamma es >1
subplot(2,2,1)
imshow(g)
RGB1 = imread('perrito.jpg');
RGB2 = imadjust(RGB1,[.2 .3 0; .6 .7 1],[]);
subplot(2,2,2)
g1= imadjust (J, [0 1], [1 0], 1.0); % gamma es = 1.0
imshow(g1);
subplot(2,2,3)
imshow(RGB2);
subplot(2,2,4)
g1 = imadjust (J, [0.2 0.8], [0.7 0.3], 0.6); %gamma <1
imshow(g1);
Transformación log:
La transfomación utilizando log.
>> g = c * log (1 + double(f))

% Transformación de log.
RGB1 = imread('perrito.jpg');
RGB2 = double(RGB1); %Imagen double
g = log(1+RGB2); %imagen doble
g1 = mat2gray(g);
g2 = im2uint8(g1);
figure(10)
subplot(1,2,1); imshow(RGB1); title('imagen original');
subplot (1,2,2);imshow(g2);title('Transformación log');

5. Histograma de la Imagen
>> imhist (f,n)
Donde n es el número de intervalos (subdivisiones de la escala de intensidad)
usados para formar el histograma, cuyo valor por defecto es 256.
>> imhist (f,n)/numel(f)
Histograma normalizado
>> g = histeq(f, n)
Histograma ecualizado, donde n indica el número de niveles de intensidad
específico para la imagen de salida, por ejemplo, n=256.
Histograma de una Imagen:

% Histograma de una imagen

f = imread('perrito.jpg');
figure(11)
f1 = rgb2gray(f)
subplot (1,3,1)
imhist(f1);
subplot(1,3,2)
histeq(f1,256);

%histograma normalizado
subplot(1,3,3)
f2=imhist(f1,120)/numel(f1)
imshow(f2);
6. Filtros especiales
>> g = imfilter(f, w, ‘replicate’)
- f es la imagen de entrada
- w es la máscara
- ‘replicate’: el tamaño de la imagen se aumenta duplicando los valores
del borde. Hay más opciones para tratar el borde.
- Las máscaras se pueden definir manualmente (como matriz). Por
ejemplo:
- >> w = 1/9*[1 1 1;1 1 1;1 1 1]; o bien
- >> w = 1/9*ones(3);
Las máscaras más implementadas en Matlab:
a) Filtros de la mediana
>> g = medfilt2(f, [m n] );
[m n] = tamaño de la máscara (por defecto 3x3).
Añadir ruido a una imagen:

>> g = imnoise(f, tipo de ruido, parámetros)

 Por ejemplo:
>> g = imnoise(f,’salt&paper’),0.2)
En esta instrucción se añade un 20% de ruido sal y pimienta.

% filtros especiales
figure(12)
subplot(2,2,1)
f = imread('perrito.jpg')
f1=rgb2gray(f);
imshow(f)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% agregando ruido
subplot(2,2,2)
g = imnoise(f1,'salt & pepper', 0.2);
imshow(g);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% filtro media
subplot(2,2,3)
m1 = fspecial('average',3);
f_med=imfilter(g,m1);
imshow(f_med);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
subplot(2,2,4)
% filtro f_mediana
f_mediana=medfilt2(g,[3 3]);
imshow(f_mediana)
figure(13);
f = imread('perrito.jpg')
m=fspecial('laplacian',0.7);
g = imfilter(f,m,'replicate');
subplot(1,2,1)
imshow(f);
subplot(1,2,2)
imshow(g);
7. Transformada Discrete de Fourier
>> F=fft2 (f)
Transformada discreta de Fourier de la imagen f, luego es una matriz de valores
complejos.
>> abs (F)
Magnitud de los valores complejos de la TDF (espectro de Fourier).
>> fftshift (F)
TDF desplazada (F(0,0) en el centro de frecuencias).
>> f=ifft2 (F)
TDF inversa.
clear all;clf
clc
J = imread('gatito.jpg');
figure; imshow(J)
I = rgb2gray(J);
figure;imshow(I);title('Original Image');
text(size(I,2),size(I,1)+15, ...
'logo de la
UNCP','FontSize',7,'HorizontalAlignment','right');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%
% tranformda de fourier
y = fft2(I)
f2 = fftshift(y);
S= abs(f2)
figure; imshow(S,[]);
s2=log(130+S);
imshow(s2,[]);
8. Morfología
Dilatación:
>> imdilate (f,SE)
Erosión:
>> imdilate (f,SE)
Apertura:
>> imopen (f,SE)
Clausura:
>> imclose (f,SE)
SE indica el elemento estructural que puede definirse a partir de la función
STREL:
>> strel(‘diamond’,R)
>> strel(‘disk’,R)
>> strel(‘line’,length, angle)
 >> strel(‘rectangle’,MN), MN=vector de dos elementos.
>> strel(‘square’,W)

figure(15)
f = imread('gatito.jpg');
SE = strel('square',35);
fdilatada = imdilate(f,SE);
ferosion = imerode(f,SE);
subplot(3,1,1)
imshow(f);
subplot(3,1,2)
imshow(fdilatada);
subplot(3,1,3)
imshow(ferosion);

1. Segmentación
>> [g, t] = edge(f, ’método’, parámetros)
La salida g es una matriz logical con 1 en los píxeles que el método detecta como borde y 0 en caso
contrario. La salida T es opcional, indica que el umbral que ha usado el método para obtener el
borde.

Sobel:
>> [g, t] = edge(f, ’sobel’, T, dir)
T umbral específico, en cuyo caso t=T.
dir = ‘horizaontal’, ‘vertical’ o ‘both’.
Prewitt:
>> [g, t] = edge(f, ’prewitt’, T, dir)
Roberts:
>> [g, t] = edge(f, ’ roberts’, T, dir)
LoG:
>> [g, t] = edge(f, ’log’, T, sigma)
sigma = desviación estándar (por defecto, sigma=2).
Canny:
>> [g, t] = edge(f, ’canny’, T, sigma)
T=[T1, T2] umbrales específicos.
sigma = desviación estándar del filtro de suavizado.

figure(16);
f = imread('gatito.jpg');
f1=rgb2gray(f);
[h1,t1]=edge(f1,'sobel');
[h2,t2]=edge(f1,'prewitt');
[h3,t3]=edge(f1,'roberts');
[h4,t4]=edge(f1,'log');
[h5,t5]=edge(f1,'canny');
subplot(2,3,1)
imshow(f1);
title('original')
subplot(2,3,2)
imshow(h1);
title('sobel');
subplot(2,3,3)
imshow(h2);
title('prewitt')
subplot(2,3,4)
imshow(h3);
title('roberts');
subplot(2,3,5)
imshow(h4);
title('log');
subplot(2,3,6)
imshow(h5);
title('canny')

10 Umbralización
>> im2bw(f, T)
Donde T es el umbral tal que todos los niveles de intensidad por debajo de T los
hace 0 y todos los que son mayores que T los hace 1. Dicho umbral se puede
obtener con la siguiente función la cual aplica el método de Otsu:
>> T=graythresh(f)
Umbralización
figure(17);
f= imread('gatito.jpg');
f1=rgb2gray(f);
subplot(1,3,1)
imshow(f);
title('original')
subplot(1,3,2)
imshow(f1);
title('gris')
subplot(1,3,3)
T=graythresh(f1);
fbinaria=im2bw(f1,T);
imshow(fbinaria);
title('binaria');
11.- Representación y descripción
Número de componentes conexas:
>> g = bwlabel(f, n)
donde n indica la adyacencia usada, es decir, n=4 o n=8. Esta función cuenta el
número de componentes conexas blancas luego, si consideramos que el objeto es
lo negro, debemos aplicar bwlabel a la imagen negativa de f.

figure(18)
f = [ 0 0 0 1;0 1 1 1; 0 0 1 1; 0 1 1 1];
subplot(1,2,1)
imshow(f);
title('Original');
[L,n]=bwlabel(f,4);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Negativo de una imagen
subplot(1,2,2)
fnegativa = not(f);
[Lneg,m]=bwlabel(fnegativa,4);
imshow(fnegativa);
title('negativo');
Función regionprops:
>> D = regionprops(L, properties)
Donde: L es una matriz de etiquetas de componentes conexas y D es una
estructura de array conteniendo propiedades de las distintas regiones de la
imagen binaria correspondiente a L.

propiedades de una imagen

f = imread('gatito.jpg');
T = graythresh(f);
fbin = im2bw(f,T);
[L,n]= bwlabel(fbin,4);
D=regionprops(L,'all');
w1 = [D.Area];
w2 = [D.Centroid];
 12 Transformaciones geométricas
>> g=padarray(f, [m n])
Rellena la imagen f añadiendo m filas de ceros en la parte superior e inferior de la
imagen y n columnas de ceros en a derecha e izquierda de la imagen.

figure(19)
f = imread('gatito.jpg');
g = padarray(f,[100 100]);
subplot(1,2,1)
imshow(f);
title('original');
subplot(1,2,2)
imshow(g);
title('modificada');
% imagen reflejada
figure(20)
f = imread('gatito.jpg');
f1 =rgb2gray(f);
h = fliplr(f1);
subplot(1,2,1)
imshow(f);
subplot(1,2,2)
imshow(h);

13.- Rotación de imágenes:

>> g=imrotate(f, angle, ‘crop’)
El tamaño de la imagen es aumentado automáticamente rellenando la imagen
hasta adaptarse a la rotación. Si incluimos el argumento ‘crop’, observar qué
ocurre con el tamaño de la imagen en el siguiente ejemplo:

%rotacion de imagenes
 figure(21)
f = imread('gatito.jpg');
r1 = imrotate(f,50);
r2 = imrotate(f,50,'crop');
subplot(1,3,1)
imshow(f);
title('original');
subplot(1,3,2)
imshow(r1);
title('sin corte');
subplot(1,3,3)
imshow(r2);
title('con corte')

Cambio de tamaño:
>> g=imresize(f,escala)
%Cambio de color
figure(22)
f = imread('gatito.jpg');
t1 = imresize(f,0.2);
t2 = imresize(f,0.5);
t3 = imresize(f,0.8);
subplot(2,2,1)
imshow(f);
title('original');
subplot(2,2,2)
imshow(t1);
title('Escala 0.2');
subplot(2,2,3)
imshow(t2);
title('Escala 0.5');
subplot(2,2,4)
imshow(t3);
title('Escala 0.8');