Delimitación de Frutas

La imagen con la que se trabajara para realizar la delimitación de futas sera la siguiente:













Para realizar la delimitación de las frutas debemos primero realizar la segmentación de la imagen y lo mas importante es la identificación de los objetos en la imagen para esto colocamos el siguiente código.

[niveles, numObjects]=bwlabel(BW,8); numObjects stats=regionprops(niveles,'Eccentricity','Area','BoundingBox'); areas=[stats.Area]; excentricidad=[stats.Eccentricity]

Este código nos permite encontrar en numero de objetos y las aéreas de los mismos, estas aéreas nos ayudaran a para realizar la delimitación de las imágenes

Con estas escogemos las que están en un rango alto por ejemplo escogemos las áreas que estén entre los rangos 2000 a 8000 y colocamos el siguiente código.

platano=find(areas>7520 & areas <> 0.5);
statsplatano=stats(platano)
figure imshow(I_original)
hold on;
for idx = 1:length(statsplatano);
h = rectangle ('Position',statsplatano(idx).BoundingBox,... 'Curvature', [1,0.8],'LineWidth',5,'LineStyle','-.');
set (h,'EdgeColor',[0 0 1]);
hold on
end

manzana=find(areas > 2750 & areas < 2990 > 0.5);
statsmanzana=stats(manzana) for idx = 1:length(statsmanzana);
h = rectangle ('Position',statsmanzana(idx).BoundingBox,... 'Curvature',
[1,0.8],'LineWidth',5,'LineStyle','-.'); set (h,'EdgeColor',[0 1 1]);
hold on
end
hold off

La parte importante es la excentricidad ya que esta depende del tipo de objetos que se vaya a delimitar si los objetos de la imagen son cerrados se colocara excentricidad <> 0.5.
Rectangle.- permite encerrar a los objetos de la imagen en un rectangulo y modificar su color y su forma.
Hold on – hold of.- permite que la imagen este activa y realizar la delimitación en la misma imagen

Segmentación de una imagen

Lo que se va a realizar a continuación es la identificación de objetos y determinar las propiedades de los mismos:

Primero se va a adquirir una imagen que contenga objetos redondos, debido a que la identificación de objetos seran mediante propiedades propias de dichos objetos.

image_or=imread('moneda.jpg');
figure; imshow(image_or);










Ahora se va a crear una imagen con una intensidad de escala de grises a partir de la imagen a color RGB, mediante el comando rgb2gray()
image=rgb2gray(image_or);
figure; imshow(image)










Se crea un elemento 'disk', es decir en forma de disco, y se lo hace para preservar la naturaleza circular del objeto.
En este caso se va a especificar un radio de 88 pixeles para llenar la cámara mas grande.
se=strel('disk',88);

Se procede a ejecutar la operación close en la imagen, que servirá para detectar el fondo de la imagen propuesta
closeBW=imclose(image,se);

Para identificar los objetos, se restan las dos matrices, es decir la matriz a escala de grises y la matriz que identifica el fondo de la imagen.
iden=imsubtract(closeBW,image);
figure; imshow(iden)











Con graythresh() se logra calcular el umbral que podrá ser utilizado para convertir una intensidad de imagena una imagen binaria utilizando im2bw
level=graythresh(iden);
intensidad=level*255

Binarizar imagen
BW=im2bw(iden,level);
figure; imshow(BW)






Se llena los agujeros de la imagen binaria BW.
fill=imfill(BX,'holes');
figure; imshow(fill)










Para identificar a cada objeto, como por ejemplo el número de objetos conectados, encontrados en la imagen BW.
[niveles, num]=bwlabel(BW,8);
num

Stats es una matrizcon longitud igual al número de objetos en la imagen binaria.
Con regionprops determina las propiedades de cada objeto conectado en la imagen binaria.
stats=regionprops(niveles,'Eccentricity','Area','BoundingBox');
Eccentricity: el valor está entre 1 y 0. Si la excentricidad es 0 se trata de un círculo, y si la excentricidad es 1 se trata de un segmento lineal.
Area: el número real de pixeles en la región.
BoundingBox: el más pequeño rectángulo que contiene la región.
areas=[stats.Area]
excentricidad=[stats.Eccentrincity]

Histograma y Umbralización

Tenemos algunos procesamientos de imágenes que son muy comunes, como son:

Histograma de una imagen

Mediante a esta función se puede determinar el número de pixeles para cada nivel de gris que exista en una imagen. Por lo tanto, si se tiene una imagen a color, lo primero que se debe proceder a realizar es cambiarla a escala de grises.

Despues de la obtención de las imágenes respectivas y guardarlas en las variables image1 e image2 respectivamente, se procede la transformación de las imágenes a escala de grises:
gray1=rgb2gray(image1);
figure; imshow(gray1)







gray2=rgb2gray(image2);
figure; imshow(gray2)

Hacemos la diferencia entre las 2 imágenes para sobreponerlas una sobre otra
gray=abs(gray1-gray2);
figure; imshow(gray)








Con las 2 imágenes en escala de grises ya se puede proceder a realizar el cálculo del histograma:
figure; imhist(gray);









Umbralización de una imagen

Se trata de escoger una valor de la intensidad y convertir todo lo que sea superior a dicho valor en 1 y todo lo inferior convertirlo a 0.
El objetivo de umbralizar es separar el fondo de los objetos, siempre y cuando estos tengan sus niveles de grises agrupados en modos nominantes.

nivel=graythresh(gray);
BW=im2bw(gray,nivel);
figure; imshow(BW)

Filtro de media y Filtro de mediana

Existen operaciones que suavizan las imagenes, su objetivo es reducir el ruido que la imagen presente al momento de su captura. Existen algunos algoritmos para lograrlo, como los filtros de Media y de Mediana.

Filtro de la Media

Genera una nueva imagen, de donde cada pixel adquiere su intensidad promediando los valores de intensidad de los pixeles vecinos.

Utilizando las imágenes anteriores, realizamos las mismas operaciones para capturar la imagen en una variable y para colocar la dimensión deseada, además de separar las 3 matrices RGB.

image_or1=imread('image1.jpg');
image_or2=imread('image2.jpg');
image1=image_or1(1:313,1:400,:);
image2=image_or2(1:313,1:400,:);
planeR1=image1(:,:,1);
planeR2=image2(:,:,1);
planeG1=image1(:,:,2);
planeG2=image2(:,:,2);
planeB1=image1(:,:,3);
planeR2=image2(:,:,3);

Para obtener el filtro de la media

[n,m]=size(planeR1);
for k=1:3
for i=2:n-1
for j=2:m-1
v=[image1(i-1,j-1) image1(i-1,j) image1(i-1,j+1) image1(i,j-1) ...
image1(i,j) image1(i,j+1) image1(i+1,j-1) image1(i+1,j)...
image1(i+1,j+1)];
v=sort(v);
image1(i,j,k)=v(5);
end
end
end
figure; imshow(image1)

Filtro de la mediana

Este filtro genera una nueva imagen, cuyos pixeles se generan calculando la mediana del conjunto de los pixeles vecinos de la imagen origen, logrando homogenizar los pixeles que tengan intensidades diferentes.

[m,n]=size(planeR2);
for i=2:m-1
for j=2:n-1
v=uint8(image2(i-1,j-1)+image2(i-1,j)+image2(i-1,j+1)+...
image2(i,j-1)+image2(i,j)+image2(i,j+1)+image2(i+1,j-1)+...
image2(i+1,j)+image2(i+1,j+1));
image2(i,j)=v/9;
end
end
figure; imshow(image2)

Y ahora un ejemplo simple que compara 2 imágenes

for k=1:3
comp(:,:,k)=image1(:,:,k)-image2(:,:,k);
end
figure; imshow(comp)

Operación con imagenes

Para realizar las operaciones básicas entre 2 imágenes, es indispensable que dichas imágenes tengan el mismo tamaño.

Para el desarrollo de la suma y la resta, el largo de la imagen 1 tiene que tener el mismo largo de la imagen 2, y el ancho de las 2 imágenes también tienen que ser iguales. A pesar de que el largo y el ancho de cada imagen no sea del mismo porte.

Para el desarrollo de la multiplicación es distinto, tanto el largo como el ancho de cada imagen tiene que ser del mismo tamaño. Y de igual forma las 2 imágenes deben tener las mismas medidas.

Adquirir las 2 imágenes (Primero se obtiene las 2 imágenes y se las guarda en las variables imagen2 e imagen2 respectivamente)
imagen1=imread('image1.jpg');
imagen2=imread('image2.jpg');

Limitar imagen (Debido a que las 2 imágenes tienen medidas distintas, se debe tomar las medidas que se deseen y guardarlas en otras variables, image1 e image2, en este caso, se escogerá una matriz de [300x300])
image1=imagen1(1:300, 50:350,:);
image2=imagen2(1:300,50:350,:);
figure; imshow(image1)
figure; imshow(image2)

Imagen 1












Imagen 2












Separamos las 3 matrices de las dos imágenes, es decir convertimos las imágenes a escala de grises
planeR1=image1(:,:,1);
planeG1=image1(:,:,2);
planeB1=image1(:,:,3);

planeR2=image2(:,:,1);

planeG2=image2(:,:,2);
planeB2=image2(:,:,3);

Diferencia de imágenes

(Se hace la diferencia entre las 2 imágenes, por cada plano)

difR=planeR1-planeR2;

figure; imshow(difR)

difG=planeG1-planeG2;

figure; imshow(difG)

difB=planeB1-planeB2;

figure; imshow(difB)

Sobreponemos las 3 diferencias realizadas anteriormente

bothd(:,:,1)=difR;

bothd(:,:,2)=difG;

bothd(:,:,3)=difB;

figure; imshow(bothd)

Suma de imágenes

(Se hace la suma entre las 2 imágenes, por cada plano)

sumR=planeR1-planeR2;

figure; imshow(sumR)

sumG=planeG1-planeG2;

figure; imshow(sumG)

sumB=planeB1-planeB2;

figure; imshow(sumB)

Sobreponemos las 3 sumas realizadas anteriormente

boths(:,:,1)=sumR;

boths(:,:,2)=sumG;

boths(:,:,3)=sumB;

figure; imshow(boths)

Multiplicación de imágenes

(Se hace la multiplicación entre las 2 imágenes, por cada plano, en este caso con el comando immultiply)

mulR=immultiply(planeR1,planeR2);

figure; imshow(mulR)

mulG=immultiply(planeG1,planeG2);

figure; imshow(mulG)

mulB=immultiply(planeB1,planeB2);

figure; imshow(mulB)

Sobreponemos las 3 multiplicaciones realizadas anteriormente

bothm(:,:,1)=mulR;

bothm(:,:,2)=mulG;

bothm(:,:,3)=mulB;

figure; imshow(bothm)

Operaciones aritméticas y Rotación

Operaciones Aritméticas

Para desarrollar una operación aritmética, se puede realizar entre dos imágenes pero ambas imágenes deben tener el mismo tamaño, o puede haber la opción de realizar operaciones entre una imagen y un escalar. Las operaciones más usadas son la suma, resta, multiplicación y división.
En este caso las operaciones se realizan con un escalar para lograr notar los efectos que puede causar.

Adquirir y presentar la imagen (Obtenemos la imagen y la guardamos en una variable llamada "image")
image=imread('image1.jpg');
figure; imshow(image)





Obtener escala de grises (Separamos los 3 planos de la imagen)
planeR=image(:,:,1);
planeG=image(:,:,2);
planeB=image(:,:,3);

Operaciones con un escalar (Realizamos las 3 operaciones fundamentales entre una imagen y un escalar y lo presentamos para visualizar sus cambios)

Resta de la imagen con un escalar (Mediante la resta entre imagenes se puede realizar procesos como detección de movimientos, si se utilizan 2 imagenes distintas, las 2 deben ser del mismo tamaño y se utiliza el comando imsubtract. En este caso la resta se realiza entre una imagen y un escalar)
filterR=planeR-2;
figure; imshow(filterR)



Multiplicación de la imagen con un escalar (La multiplicación se realliza entre 2 imágenes del mismo tamaño, mediante el comando immultiply. Si la multiplicación se lo realiza con un escalar, se lo llama escalamiento, si escalar<1>1 aumenta el brillo de la imagen)
filterG=planeG*2;
figure; imshow(filterG)




Suma de la imagen con un escalar (Si se realiza la suma entre 2 imágenes, las 2 deben ser del mismo tamaño. Al sumar con un escalar, el brillo de la imagen aumenta)
filterB=planeB+2;
figure; imshow(filterB)





Superponer lo realizado con las 3 operaciones anteriores (Al superponer lo realizado anteriormente en una sola variable se presentará la imagen a color con las respectivas modificaciones)
filterRGB(:,:,1)=filterR;
filterRGB(:,:,2)=filterG;
filterRGB(:,:,3)=filterB;
figure; imshow(filterRGB)


Rotar la imagen

La rotación de una imagen, se logra desarrollando la matriz transpuesta de cada plano de la imagen, es decir de cada matriz que la compone, y al finalizar superponerlas para lograr apreciar la imagen a color.
planeR=planeR';
planeG=planeG';
planeB=planeB';
rotate(:,:,1)=planeR;
rotate(:,:,2)=planeG;
rotate(:,:,3)=planeB;
figure; imshow(rotate)

Si se desea rotar la imagen con un valor de grado determinado, por ejemplo 30 grados

rot=imrotate(image1,30,'nearest');

figure; imshow(rot)

Imágenes

Imagen a escala de grises: representado por una matriz bidimensional de [mxn] elementos, en donde n representa el número de pixeles de ancho y m el número de pixeles de largo.

Imagen a color RGB (Red, Green, Blue): representado por una matriz tridimensional de [mxnxp] elementos, donde p representa el plano, es decir, 1 para el rojo, 2 para el verde y 3 para el azul.

Ejemplo:

Obtener y presentar una imagen (Adquiere una imagen a color y la guarda en una variable llamada "image" para poder presentarla en pantalla)
image=imread('image1.jpg');
figure; imshow(image)










Escala de grises de la imagen (Presenta los tres planos que tienen la imagen RGB, es decir presenta la matriz roja, verde y azul)
image2=image(:,:);
figure; imshow(image2)








Obtener primer plano (Presenta solo la matriz roja de la imagen)
planeR=image(:,:,1);
figure; imshow(planeR)










Obtener segundo plano (Presenta solo la matriz verde de la imagen)
planeG=image(:,:,2);
figure; imshow(planeG)










Obtener tercer plano (Presenta solo la matriz azul de la imagen)
planeB=image(:,:,3);
figure; imshow(planeB)










Conocer los datos de un pixel (Se puede selexionar un pixel de la imagen que se presenta y automáticamente se guardará las coordenadas en la variable llamada "value")
figure; imshow(planeR)
value=impixel;










Variable con las coordenadas del pixel seleccionado




Analizar cambios de un segmento (se puede escoger un segmento de la imagen presentada y se presentará un gráfico que describe los cambios de dicho segmento)
figure; imshow(planeR)
improfile;










Gráfica descriptiva del segmento seleccionado