PROCESAMIENTO DIGITAL DE IMAGENES

TALLER #3
OPERACIÓN PIXEL A PIXEL

INTEGRANTES:
HENRY ALBRTO GARCIA

ANDRES PLAZAS SIERRA

ING. FREDY NOCUA

UNISANGIL-YOPAL
2020
 OPERACIÓN PIXEL A PIXEL
TALLER #3

1. Los histogramas son distribuciones que describen la frecuencia con la que se presentan los valores
de intensidad (Píxeles) de la imagen. Realizar un algoritmo que calcule el histograma de una imagen
a color, es decir que muestre el histograma de cada canal. Se sugiere mostrar los resultados
utilizando el comando subplot para que aparezca en una sola figura.

[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no se cargo correctamente');
return
end
A=imread(fullfile(pathname,filename));

R=A(:,:,1);
G=A(:,:,2);
B=A(:,:,3);

[count1,x]=imhist(R,256);
[count2,x]=imhist(G,256);
[count3,x]=imhist(B,256);

subplot(3,3,1), imshow(R);
subplot(3,3,2), stem(x,count1);
subplot(3,3,4), imshow(G);
subplot(3,3,5), stem(x,count2);
subplot(3,3,7), imshow(B);
subplot(3,3,8), stem(x,count3);

2. Los sistemas computacionales de hoy en día tiene la capacidad para realizar ciento de operaciones
aritmético lógicas en un segundo, utilizar los comandos de Matlab para calcular el histograma de
una secuencia de video, capturados por la webcam.
clear all
clc
vid=videoinput('winvideo',1,'YUY2_640x480');
preview(vid)

for i=1:1000

A=getsnapshot(vid);
C=A(:,:,1);
[count,x]=imhist(A,256);
subplot(1,2,1),imshow(C);
subplot(1,2,2),stem(x,count);
end

3. Las operaciones individuales implican la generación de una nueva imagen modificando el valor del
pixel. El proceso consiste en obtener el valor del pixel de una localización dada en la imagen,
modificándola por una operación lineal o no lineal y colocando el nuevo valor del pixel en la
correspondiente localización de la nueva imagen.

Como se puede apreciar en la figura anterior, el operador indibiudual es una transformacion uno a uno. El
operador f se aplica a cada píxel en la imagen o seccion y la salida depende unicamente de la magnitud del
correspondiente pixel de entrada; la salida es independiente de los pixeles ayacentes. La funsion de
transformacion el valor de gris de cada píxel en la imagen y el nuevo valor se obtienen atravez de la
ecuacion,
%% Q(y,x)=F(P(y,x));

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
F=imread(fullfile(pathname,filename));
%% Procesamiento
P= 13
R= F*P;
A= R;
%% Mostrar la imagen
subplot(2,2,1),imshow(F);
title('Imagen normal');
subplot(2,2,2),imhist(F)
subplot(2,2,3),imshow(A);
title('Imagen procesada');
subplot(2,2,4),imhist(A);
 4. Operador inverso negativo. Este operador crea una imagen crea una imagen de salida que es le entrada, La
función de transformación: Realizar la transformación inversa de una imagen a escala de grises, y mostrar los
resultados en una sola figura.

%%%%% cargar la imagen %%%%%%

% Q=255-P
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('archivo no encontrado');
end

A=imread(fullfile(pathname,filename));
B=double(A(:,:,1));

C=255-B;

[count1,x]=imhist(uint8(B),256);
[count2,x]=imhist(uint8(C),256);

subplot(2,2,1), imshow(uint8(B));
subplot(2,2,2), stem(x,count1);
subplot(2,2,3), imshow(uint8(C));
subplot(2,2,4), stem(x,count2);
 5. Operador umbral Esta clase de transformación crea una imagen de salida binaria de una imagen de grises,
donde el nivel de transición está dado por el parámetro de entrada p1. La función de transformación es la
siguiente, Realizar la transformación Umbral de una imagen a escala de grises, y mostrar los resultados en
una sola figura; utilice el valor de p1 de 160.

%%%%% ingresar la imagen %%%%%%

% 0 PARA P<=P1
% 255 PARA P>P1

[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('archivo no encontrado');
end

A=imread(fullfile(pathname,filename));
D=rgb2gray(A);
[M,N]=size(D)
p1=160
for j=1:M
for i= 1:N
if (D(j,i)>p1)
imgBin(j,i)=255;
else
imgBin(j,i)=0 ;
end
end
end
subplot(2,1,1), imshow(D);
title('Imagen a gris');
subplot(2,1,2), imshow(imgBin);
title('Operador umbral');
 6. Esta clase de transformación crea una imagen de salida binaria a partir de una imagen de grises, donde
todos los valores de gris cuyos niveles están en el intervalo definido por p1 y p2 son transformados en 0 y
todos los valores fuera de este intervalo son transformados a 255. La función de transformación es la
siguientes: Realizar la transformación Umbral de una imagen a escala de grises, y mostrar los resultados en
una sola figura; utilice el valor de p1 de 60 y p2 de 140.

%OPERADOR INTERVALO DE UMBRAL BINARIO INVERTIDO

%%%%% ingresar la imagen %%%%%%
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%D=rgb2gray(I);
D=double(I(:,:,1));
[M,N]=size(D)
p1=80,p2=120
%%
for j=1:M
for i= 1:N
if (D(j,i)<p1 || D(j,i)>p2)
imgUEGN(j,i)=255;
else
imgUEGN(j,i)= 255-D(j,i);
end
end
end
subplot(2,1,1),imshow(I);
title('Imagen normal');
subplot(2,1,2),imshow(imgUEGN);
title('Imagen umbral invertido');
7. Realizar las siguientes operaciones sobre una imagen. Mostrar los resultados de la transformación en una
sola figura, además con sus respectivos histogramas. Concluya sobre la incidencia que tiene las operaciones
antes descritas sobre el contraste de la imagen y el brillo.

𝐼𝑠(𝑥,𝑦)=𝑓(𝑥,𝑦)=𝑐∗𝐼𝑒(𝑥,𝑦)+𝑏

a) c=0; b=20 b) c=0.5; b=0; c) c=0.5; b=20; d) c=1.2; b=-20

b) %% IS(X,Y)=F(X,Y)=C*Ie(X,Y)+B
c)
d) %% Cargar la imagen
e) [filename,pathname]=uigetfile('*.jpg','abrir');
f) if(pathname==0)
g) errordlg('Archivo no encontrado');
h) end
i) IM=imread(fullfile(pathname,filename));
j) %% Constantes
k) I=0;J=20;K=0.5;L=0;M=0.5;N=20;O=1.2;P=20;
l) Ie= 0:1:255;
m) %% Procesamiento
n) f= I*Ie+J;
o) A= f(IM+1);
p) %% Procesamiento
q) f= K*Ie+L;
r) B= f(IM+1);
s) %% Procesamiento
t) f= M*Ie+N;
u) C= f(IM+1);
v) %% Procesamiento
w) f= O*Ie+P;
x) D= f(IM+1);
y) %% Mostrar la imagen
z) subplot(3,2,1),imshow(IM);
aa) title('Imagen normal');
bb) subplot(3,2,2),imshow (uint8(A));
cc) title('Imagen I=0;J=20');
dd) subplot(3,2,3),imshow (uint8(B));
ee) title('Imagen K=0.5;L=0');
ff) subplot(3,2,4),imshow(uint8(C));
gg) title('Imagen M=0.5;N=20');
hh) subplot(3,2,5),imshow (uint8(D));
ii) title('Imagen O=1.2;P=20');
8. Utilizando el proceso anteriormente descrito, realizar las siguientes operaciones sobre una imagen. Mostrar
los resultados junto con los respectivos histogramas.
A.
%% Is(y,x)=-1.3*Ie(y,x)+50

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%% Constantes
x=-1.3;
y=50;
%% Procesamiento
Ie= 0:1:255;
f= x*Ie+y;
A= f(I+1);

%% Mostrar la imagen
subplot(2,2,1),imshow(I);
title('Imagen normal');
subplot(2,2,2),imhist(I)
subplot(2,2,3),imshow(uint8(A));
title('Imagen procesada');
subplot(2,2,4),imhist(uint8(A));

b. %% Is (y,x)=(Ie(y,x))^2

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%% Procesamiento
Ie= 0:1:255;
f= Ie.^2;
A= f(I+1);
%% Mostrar la imagen
subplot(2,2,1),imshow(I);
title('Imagen normal');
subplot(2,2,2),imhist(I)
subplot(2,2,3),imshow(uint8(A));
title('Imagen procesada');
subplot(2,2,4),imhist(uint8(A));

C. %% Is (y,x)=(Ie(y,x))^1/2

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%% Procesamiento
Ie= 0:1:255;
f= Ie.^1/2;
A= f(I+1);
%% Mostrar la imagen
subplot(2,2,1),imshow(I);
title('Imagen normal');
subplot(2,2,2),imhist(I)
subplot(2,2,3),imshow(uint8(A));
title('Imagen procesada');
subplot(2,2,4),imhist(uint8(A));

D. %% Is (y,x)=sin(Ie(y,x))

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%% Procesamiento
Ie= 0:1:255;
f= sin(Ie);
A= f(I+1);
%% Mostrar la imagen
subplot(2,2,1),imshow(I);
title('Imagen normal');
subplot(2,2,2),imhist(I)
subplot(2,2,3),imshow(A);
title('Imagen procesada');
subplot(2,2,4),imhist(A);

E.
%% Is (y,x)=cos(Ie(y,x))

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%% Procesamiento
Ie= 0:1:255;
f= cos(Ie);
A= f(I+1);
%% Mostrar la imagen
subplot(2,2,1),imshow(I);
title('Imagen normal');
subplot(2,2,2),imhist(I)
subplot(2,2,3),imshow(A);
title('Imagen procesada');
subplot(2,2,4),imhist(A);
F.
%% Is (y,x)= (ln(1+Ie(y,x))/ln(1+1))

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
%% Procesamiento
Ie= 0:1:255;
f= (log(1+Ie)/log(1+1));
A= f(I+1);
%% Mostrar la imagen
subplot(2,2,1),imshow(I);
title('Imagen normal');
subplot(2,2,2),imhist(I)
subplot(2,2,3),imshow(A);
title('Imagen procesada');
subplot(2,2,4),imhist(uint8(A));

9. En nuestros algoritmos muchas veces vamos a realizar operaciones sobre nuestras imágenes, en los que los
valores de la imagen transformada van a depender del nivel de gris de la imagen original. Esto quiere decir
que, si vamos pixel a pixel en la imagen original realizando la operación y escribiendo el resultado en la
imagen destino, vamos a repetir el mismo calculo infinidad de veces, tantas como el número de pixeles que
tenga el mismo nivel de gris.
 A.
%% Is(y,x)=1.3*Ie(y,x)-50

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
D=rgb2gray(I);
%% Constantes
x=1.5;
y=-50;
%% Procesamiento
Ie= 0:1:255;
f= x*Ie+y;
A= f(D+1);

%% Mostrar la imagen
subplot(2,2,1),imshow(D);
title('Imagen normal');
subplot(2,2,2),imhist(D)
subplot(2,2,3),imshow(uint8(A));
title('Imagen procesada');
subplot(2,2,4),imhist(uint8(A));

b
%% Is (x,y)=(I(x,y))^1/2

clear all
clc

%% Cargar la imagen
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('Archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
D=rgb2gray(I);

%% Procesamiento
f= I.^1/2;
A= f(I+1);
%% Mostrar la imagen
subplot(2,2,1),imshow(D);
title('Imagen normal A GRIS');
subplot(2,2,2),imhist(D)
subplot(2,2,3),imshow(uint8(A));
title('Imagen procesada');
subplot(2,2,4),imhist(uint8(A));
 C.
%%%%% ingresar la imagen %%%%%%
[filename,pathname]=uigetfile('*.jpg','abrir');
if(pathname==0)
errordlg('archivo no encontrado');
end
I=imread(fullfile(pathname,filename));
D=rgb2gray(I);
[M,N]=size(D)
p1=80,p2=120
for j=1:M
for i= 1:N
if (D(j,i)<=p1 || D(j,i)>=p2)
imgUEGN(j,i)=255;
else
H= 255- D;
end
end
end
subplot(2,1,1),imshow(D);
title('Imagen normal');
subplot(2,1,2),imshow(H);
title('Imagen umbral invertido');