Trabajo:

Practica #01
Asignatura:

Visin Por Computadora

Profesor:

Carlos Hugo Garca

capuln

Alumno:

Jos Alfredo Macario

Castillo Mendoza

Carrera:

Ing. en Mecatrnica

Fecha:

14/02/2015
Primer Programa Aplicando Operadores Para Deteccin de Bordes:
Para este programa se modific el cdigo base asignado desde el curso anterior de PDI
de tal manera que se hiciera la deteccin de bordes de las imgenes, y despus con
este programa aplicar una entidad de vecindad de 3x3 para los tres siguientes
operadores.

f
( E3,1 E3,2 E3,3 ) ( E1,1 E1,2 E1,3 )
x
f
( E3,1 E3,2 E3,3 ) ( E1,1 E1,2 E1,3 )
y
Prewitt W, Prewitt N, Prewitt NW:

Programa para deteccin de bordes:

/* **********************************************************************

PROCESAMIENTO DIGITAL DE IMAGENES

Biblioteca Basica de Funciones

Autor: Dr. Carlos Hugo Garcia Capulin

Ver 1.2

Prohibido su uso, distribucion y copia sin autorizacion por parte del autor.

INSTITUTO TECNOLOGICO SUPERIOR DE IRAPUATO.

**********************************************************************

*/

#include<stdio.h>

#include<stdlib.h>

#include<conio.h>

/* ***************** ESTRUCTURAS DE DATOS ****************************** */

typedef unsigned char byte; // Tipo de dato de 1 byte

typedef unsigned short int word; // Tipo de dato de 2 bytes

typedef unsigned long int dword; // Tipo de dato de 4 bytes

typedef struct{ byte id[1]; // Identificador de fila BMP

 word offset; // Offset al
principio de la imagen

word ancho; // Columnas

de la imagen

word alto; // Filas de la

imagen

byte bpp; // Bits de color

por pixel

int size; // Tamao de

la imagen

byte *head; // Puntero al encabezado

float *imx; // Puntero al

inicio de la imagen

}gcIMG;

gcIMG* gcGetImgBmp(char *ruta);//FUNCION PARA CONCEGUIR IMAGEN

void gcPutImgBmp(char *ruta, gcIMG *img);//FUNCION PARA GUARDAR LA

IMAGEN MODIFICADA

gcIMG* gcNewImg(int ancho,int alto);//RESERVA ESPACIO PARA UNA IMAGEN

NUEVA

void gcFreeImg (gcIMG *img);//FUNCION PARA LIBERAR EL ESPACIO USADO EN

MEMORIA

void Dimenciones(gcIMG *Imaggg);//FUNCION PARA MOSTRAR LAS DIMENCIONES

gcIMG* Convolucion(gcIMG *Ima,float *Mask);////FUNCIN PARA CONVOLUCIN

gcIMG* Normalizado(gcIMG *Ima);////fUNCIN PARA NORMALIZADO

float* Mascara();////FUNCIN PARA MASCARA

//FUNCIN PRINCIPAL

int main(void)
{ gcIMG *Img,*a,*b;

float *Mask;

int i,j;

Img=gcGetImgBmp("C:\\Users\\makogane\\Desktop\\bleach3.bmp");

Dimenciones(Img);

Mask=Mascara();

a=Convolucion(Img,Mask);

b=Normalizado(a);

gcPutImgBmp("C:\\Users\\makogane\\Desktop\\SOBEL.bmp",b);

gcFreeImg(Img);

free(Mask);

gcFreeImg(b);

system("PAUSE");

return 0;

//FUNCIN PARA MASCARA

float* Mascara()

{ int M,N,i,j;

float *A;

printf("\nNumero de filas de Mascara\n");

 scanf("%i",&M);

printf("\nNumero de columnas de Mascara\n");

scanf("%i",&N);

A=(float *)malloc(M*N*sizeof(float));

for(i=0;i<M;i++)

{ for(j=0;j<N;j++)

{ printf("\n M[%i][%i]=",i,j);

scanf("%f",&*(A+i*N+j));

for(i=0;i<M;i++)

{ printf("\n");

for(j=0;j<N;j++)

printf("%f \t",A[i*M+j]);

return (A);

//FUNCIN PARA OBTENER DIMENCIONES

void Dimenciones(gcIMG *Imaggg)

{ printf("\n El ancho es: %i",Imaggg->ancho);

printf("\n El alto es: %i",Imaggg->alto);

printf("\n El tamano es: %i\n\n",Imaggg->size);

}
//FUNCIN PARA CONVOLUCION

gcIMG* Convolucion(gcIMG *Ima,float *Mask)

{ gcIMG *A;

unsigned int i,j;

A=gcNewImg(Ima->ancho,Ima->alto);

for(i=1;i<(Ima->alto-1);i++)

{ for(j=1;j<(Ima->ancho-1);j++)

{ A->imx[(i*A->ancho)+j]=((Ima->imx[(((i-1)*Ima->ancho)+(j-1))]*Mask[8])

+(Ima->imx[(((i-1)*Ima->ancho)+j)]*Mask[7])

+(Ima->imx[(((i-1)*Ima->ancho)+(j+1))]*Mask[6])

+(Ima->imx[((i*Ima->ancho)+(j-1))]*Mask[5])

+(Ima->imx[((i*Ima->ancho)+j)]*Mask[4])

+(Ima->imx[((i*Ima->ancho)+(j+1))]*Mask[3])

+(Ima->imx[(((i+1)*Ima->ancho)+(j-1))]*Mask[2])

+(Ima->imx[(((i+1)*Ima->ancho)+j)]*Mask[1])

+(Ima->imx[(((i+1)*Ima->ancho)+(j+1))]*Mask[0]));

return (A);

//fUNCION PARA NORMALIZADO

gcIMG* Normalizado(gcIMG *Ima)

{ gcIMG *I;
 unsigned int i;

float Ma,me,den,fac;

I=gcNewImg(Ima->ancho,Ima->alto);

Ma=Ima->imx[0];

for(i=0;i<Ima->size;i++)

{ Ima->imx[i];

if(Ima->imx[i]>Ma)

{ Ma=Ima->imx[i];}

me=Ima->imx[0];

for(i=0;i<Ima->size;i++)

{ Ima->imx[i];

if(Ima->imx[i]<me)

{ me=Ima->imx[i];}

den=Ma-me;

fac=255/den;

for(i=0;i<Ima->size;i++)

{ I->imx[i]=(fac*(Ima->imx[i]-me));}

gcFreeImg(Ima);

return (I);

/* FUNCIONES BASE DE PROCESAMIENTO DE IMAGENES */

/********************Funcion Uno ***********************************

Garcia Capulin Get Image Bmp

gcGetImgBmp()
Funcion que lee un archivo bmp y lo coloca en memoria para su Proc.

*/

gcIMG* gcGetImgBmp(char *ruta)

{ gcIMG *img;

FILE *file;

int i,j,a,ar;

// Abrir Archivo de entrada

if ( (file = fopen(ruta,"rb"))==NULL )

{ printf(" Error al Abrir Archivo \n");

exit(1);

// Asignar memoria para la estructura gcIMG

if ( (img = (gcIMG *) calloc(1,sizeof(gcIMG)) ) == NULL)

{ printf("Error al reservar memoria para gcIMG \n");

exit (1);

fread(img->id,2,1,file); // Lee 2 bytes del identificador

fseek(file,10,SEEK_SET); // Se posiciona en Data offset

fread(&img->offset,2,1,file); // Lee el offset de la Imagen

fseek(file,18,SEEK_SET); // Se posiciona en Width

fread(&img->ancho,2,1,file); // Lee el ancho de la Imagen

fseek(file,22,SEEK_SET); // Se posiciona en Height

fread(&img->alto,2,1,file); // Lee el alto de la Imagen

fseek(file,28,SEEK_SET); // Se posiciona en Bits p/pixel

 fread(&img->bpp,1,1,file); // Lee los Bpp

fseek(file,34,SEEK_SET); // Se posiciona en Size

fread(&img->size,4,1,file); // Lee el tamao de la Imagen */

// Comprobar archivo valido

if ( (img->id[0]!='B')||(img->id[1]!='M') )

{ printf("Archivo de Formato No Valido \n");

exit (1);

// Asignar memoria para el encabezado

if ( (img->head = (unsigned char *) malloc(img->offset)) == NULL )

{ printf("Error al reservar memoria para el encabezado \n");

exit (1);

// Asignar memoria para la imagen real

if ( (img->imx =(float *)calloc(img->ancho*img->alto,sizeof(float))) == NULL )

{ printf("Error al reservar memoria para la imagen \n");

exit (1);

// Lectura del encabezado

rewind(file);

fread(img->head,1078,1,file);
// Lectura de la imagen

a=img->ancho;

ar=img->size/img->alto; //calcula el ancho real

fseek(file,img->offset,SEEK_SET); // Se posiciona al inicio de la imagen

for (i=0; i<img->alto; i++)

{ for(j=0; j<img->ancho; j++)

img->imx[i*a+j]=(float)fgetc(file);

if(ar!=a) for(j=0;j<ar-a;j++) fgetc(file); // Si el ancho es mayor

} // brinca esos datos

fclose(file);

img->size=img->ancho*img->alto; //Asigna el Tamao Real de la Imagen

return img;

/******************** Funcion Dos ***********************************

Garcia Capulin Put Image Bmp

gcPutImgBmp()

Funcion que envia a un archivo bmp una imagen en memoria.

*/

void gcPutImgBmp(char *ruta, gcIMG *img)

{ FILE *file;

int aux,zero=0,i,j,offset,Newancho;

// Crear un Archivo nuevo

if ((file = fopen(ruta,"w+b")) == NULL)

 { printf("\nError abriendo el archivo \n");

exit(1);

//Checar si el ancho es multiplo de 4

offset=img->ancho%4;

if (offset) Newancho=img->ancho+(4-offset); //Si no hacerlo multiplo

else Newancho=img->ancho; // Si, si mantenerlo

// Checar el encabezado

if (img->head) { img->size=(Newancho*img->alto); //Modificar el bitmap size

fwrite(img->head,1078,1,file);

// Generar encabezado:

else {

fputc('B',file); fputc('M',file); // Escribe BMP Identificador

aux = Newancho * img->alto + 1078;

fwrite(&aux,4,1,file); // Escribe
File Size

fwrite(&zero,4,1,file); // Escribe
Word Reserved

aux=1078;

fwrite(&aux,4,1,file); // Escribe
Data Offset

// Image Header

aux=40;

fwrite(&aux,4,1,file); // Escribe
Header Size

aux=img->ancho;
 fwrite(&aux,4,1,file); // Escribe
Width

aux=img->alto;

fwrite(&aux,4,1,file); // Escribe
Height

aux=1;

fwrite(&aux,2,1,file); // Escribe
Planes

aux=8;

fwrite(&aux,2,1,file); // Escribe
Bits p/pixel

aux=0;

fwrite(&aux,4,1,file); // Escribe
Compression

aux=(Newancho*img->alto);

fwrite(&aux,4,1,file); // Escribe
Bitmap Size

aux=0;

fwrite(&aux,4,1,file); // Escribe
HResolution

fwrite(&aux,4,1,file); // Escribe VResolution

aux=256;

fwrite(&aux,4,1,file); // Escirbe Colors used

aux=0;

fwrite(&aux,4,1,file); // Escirbe Important Colors

// Escritura de la paleta

for (aux=0; aux<256; aux++)

{ for (i=0; i<3; i++) fwrite(&aux,1,1,file);

 fwrite(&zero,1,1,file);

// Escritura del mapa de bits

aux=img->ancho;

for(i=0;i<img->alto;i++)

for(j=0;j<Newancho;j++)

{ if(j>aux-1) fputc(0,file);

else fputc((unsigned char)img->imx[i*aux+j],file);

fclose(file);

/******************** Funcion Tres ***********************************

Garcia Capulin New Image

gcNewImg()

Funcion que genera una matriz vacia de una imagen en memoria.

*/

gcIMG *gcNewImg(int ancho,int alto)

gcIMG *img;

int i;

if (( img = (gcIMG *) calloc(1,sizeof(gcIMG)) ) == NULL)

{ printf("Error al reservar memoria para gcIMG\n");

 exit (1);

img->ancho = ancho;

img->alto = alto;

img->size = ancho*alto;

if (( img->imx = (float *) calloc(img->size,sizeof(float)) ) == NULL)

{ printf("Error al reservar memoria para la Imagen \n");

exit (1);

img->head = NULL;

return img;

/******************** Funcion Cuatro ***********************************

Garcia Capulin Free Image

gcfreeImg()

Funcion que libera la memoria de una imagen.

*/

void gcFreeImg (gcIMG *img)

{ free(img->head);

free(img->imx);

free(img);

}
Deteccin de Bordes Usando el Operador Matemtico Prewitt W:

El operador matemtico Prewitt W se puede aplicar mediante la convolucin o

correlacin utilizando la siguiente mascara:

Corriendo el programa de deteccin de bordes para una entidad de vecindad de 3x3.

 Ingresando la mscara para el operador.

El programa realizo el operador Prewitt W para deteccin de bordes correctamente.

Imagen original usada para el procesamiento de deteccin de bordes llamada bleach3.
Imagen resultante del procesamiento de deteccin de bordes llamada Prewitt.
Deteccin de Bordes Usando el Operador Matemtico Prewitt N:

El operador matemtico Prewitt N se puede aplicar mediante la convolucin o

correlacin utilizando la siguiente mascara:

Corriendo el programa de deteccin de bordes para una entidad de vecindad de 3x3.

 Ingresando la mscara para el operador.

El programa realizo el operador Prewitt N para deteccin de bordes correctamente.

Imagen original usada para el procesamiento de deteccin de bordes llamada bleach3.
Imagen resultante del procesamiento de deteccin de bordes llamada Prewitt N.
Deteccin de Bordes Usando el Operador Matemtico Prewitt NW:

El operador matemtico Prewitt NW se puede aplicar mediante la convolucin o

correlacin utilizando la siguiente mascara:

Corriendo el programa de deteccin de bordes para una entidad de vecindad de 3x3.

 Ingresando la mscara para el operador.

El programa realizo el operador Prewitt N para deteccin de bordes correctamente.

Imagen original usada para el procesamiento de deteccin de bordes llamada bleach3.
Imagen resultante del procesamiento de deteccin de bordes llamada Prewitt NW.
 Conclusiones:
La aplicacin de las mscaras se logr correctamente para los operadores matemticos
Prewitt W,Prewitt N y Prewitt NW por medio de los conocimientos adquiridos en el
transcurso de la materia de procesamiento digital de imgenes y usando el programa
bsico de procesamiento de imgenes otorgado por el profesor al inicio del curso, para
lo cual se vio que las mscaras aplicadas para la deteccin de bordes segn los
operadores correspondientes son excelentes opciones a utilizar en este procesamiento
de imgenes.