/**************************************************************************************************
* pgm Read File
**************************************************************************************************/
unsigned char *pgmReadFile(char *fname, int *ncols, int *nrows)
{
unsigned char *ptr;
FILE *fp;
/* Open file */
if ( (fp = fopen(fname, "rb")) == NULL)
{
printf("(pgmReadFile) Can't open file named '%s' for reading\n", fname);
}
/* Read file */
ptr = pgmRead(fp, ncols, nrows);
/* Close file */
fclose(fp);
return ptr;
}
int main (int argc, char *argv[])
{
long rowsA, colsA; /* Dimensiones de la imagen A */
long rowsB, colsB; /* Dimensiones de la imagen B */
unsigned char **imageA; /* Array 2D para la imagen A */
unsigned char **imageB; /* Array 2D para la imagen B */
int readOK, writeOK; /* Controlan la E/S de disco */
FILE* f;
long i, j, x, y, w, h;
/* Comprobamos el número de parametros */
if (argc!=7)
{
printf("\nUso: %s <img A> <img B> <list> <w> <h> <out img C>.\n\n",argv[0]);
exit(0);
}
w = atoi(argv[4]);
h = atoi(argv[5]);
/* Reservamos memoria dinámica para la imagen */
imageA = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageA[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Reservamos memoria dinámica para la imagen */
imageB = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageB[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Leemos la imagen A de disco */
readOK = pgmRead (argv[1],&rowsA,&colsA,imageA);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[1]);
exit(1);
}
/* Leemos la imagen B de disco */
readOK = pgmRead (argv[2],&rowsB,&colsB,imageB);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[2]);
exit(1);
}
f = fopen(argv[3],"r");
if (f==NULL)
{
printf("\nError al abrir el archivo: %s.\n",argv[3]);
}
/*
int m,n;
for(m=0;m<512;m=m+w)
{
for(n=0;n<512;n=n+h)
{
for(i=m;i<(m + w);i++)
{
for(j=n;j<(n + h);j++)
{
if (i==m) imageA[i][j] = 255;
if (i==(m+w)-1) imageA[i][j] = 255;
if (j==n) imageA[i][j] = 255;
if (j==(n+h)-1) imageA[i][j] = 255;
}
}
}
}
*/
fscanf(f,"%ld %ld",&x, &y);
while(!feof(f))
{
/* Copiamos el trozo de B en A */
for(i=y;i<y+h;i++)
{
for(j=x;j<x+w;j++)
{
imageA[i][j] = imageB[i][j];
//imageA[i][j] = 128;
}
}
fscanf(f,"%ld %ld",&x, &y);
}
/* Guardamos la imagen en disco */
writeOK = pgmWrite(argv[6],rowsA,colsA,imageA,NULL);
if (writeOK)
{
printf("\nEl archivo: %s, se ha creado con éxito.\n",argv[6]);
}
else
{
printf("\nError al crear la imagen: %s.\n",argv[6]);
}
return 0;
}
int main (int argc, char *argv[])
{
long rowsA, colsA; /* Dimensiones de la imagen A */
long rowsB, colsB; /* Dimensiones de la imagen B */
unsigned char **imageA; /* Array 2D para la imagen A */
unsigned char **imageB; /* Array 2D para la imagen B */
unsigned char **imageC; /* Array 2D para la imagen C */
int readOK, writeOK; /* Controlan la E/S de disco */
long i;
/* Comprobamos el número de parametros */
if (argc!=4)
{
printf("\nUso: %s <in_filenameA> <in_filenameB> <out_filenameC>.",argv[0]);
printf("\n\nin_filenameA = Image PGM.");
printf("\nin_filenameB = Image PGM.");
printf("\nout_filenameC = Image PGM.\n\n.");
exit(0);
}
/* Reservamos memoria dinámica para la imagen */
imageA = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageA[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Reservamos memoria dinámica para la imagen */
imageB = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageB[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Reservamos memoria dinámica para la imagen */
imageC = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageC[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Leemos la imagen A de disco */
readOK = pgmRead (argv[1],&rowsA,&colsA,imageA);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[1]);
exit(1);
}
/* Leemos la imagen B de disco */
readOK = pgmRead (argv[2],&rowsB,&colsB,imageB);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[2]);
exit(1);
}
/* Comprobamos que las dos imágenes tienen las mismas dimensiones */
if (rowsA==rowsB && colsA==colsB)
{
/* Generamos la imagen C con las diferencias de A - B */
differences(imageA,imageB,imageC,rowsA,colsA);
/* Guardamos la imagen residuo en disco */
writeOK = pgmWrite(argv[3],rowsA,colsA,imageC,NULL);
if (writeOK)
{
printf("\nEl archivo: %s, con la imagen residuo se ha creado con éxito.\n\n",argv[3]);
}
else
{
printf("\nError al crear la imagen residuo: %s.\n\n",argv[3]);
}
}
else
{
printf("\nLas imágenes no tienen las mismas dimensiones.\n");
}
return 0;
}
int main (int argc, char *argv[])
{
long rowsA, colsA; /* Dimensiones de la imagen A */
unsigned char **imageA; /* Array 2D para la imagen A */
unsigned char **imageB; /* Array 2D para la imagen B */
FILE* file;
int readOK, writeOK; /* Controlan la E/S de disco */
long nwritten;
long i, j, ib, jb;
long x, y, w, h;
/* Comprobamos el número de parametros */
if (argc!=7)
{
printf("\nUso: %s <in_filenameA> <out_filenameB> <x> <y> <w> <h>.",argv[0]);
printf("\n\nin_filenameA = Image PGM.");
printf("\nout_filenameB = Image PGM.\n\n");
exit(0);
}
x = atoi(argv[3]);
y = atoi(argv[4]);
w = atoi(argv[5]);
h = atoi(argv[6]);
/* Reservamos memoria dinámica para la imagen */
imageA = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageA[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Reservamos memoria dinámica para la imagen */
imageB = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageB[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Leemos la imagen A de disco */
readOK = pgmRead (argv[1],&rowsA,&colsA,imageA);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[1]);
exit(1);
}
/* Extraemos un trozo de imagen de A */
ib = 0;
for(i=x;i<x+h;i++)
{
jb = 0;
for(j=y;j<y+w;j++)
{
imageB[ib][jb] = imageA[i][j];
jb++;
}
ib++;
}
/* Guardamos la imagen en disco */
writeOK = pgmWrite (argv[2],ib,jb,imageB,NULL);
if (writeOK)
{
printf("\nEl archivo: %s, se ha creado con éxito.",argv[2]);
}
else
{
printf("\nError al crear la imagen: %s.",argv[2]);
}
return 0;
}
int main (int argc, char *argv[])
{
long rowsA, colsA; /* Dimensiones de la imagen A */
long rowsB, colsB; /* Dimensiones de la imagen B */
unsigned char **imageA; /* Array 2D para la imagen A */
unsigned char **imageB; /* Array 2D para la imagen B */
int readOK, writeOK; /* Controlan la E/S de disco */
FILE* f;
long i, j;
/* Comprobamos el número de parametros */
if (argc!=4)
{
printf("\nUso: %s <img A> <img B> <out img C>.\n\n",argv[0]);
exit(0);
}
/* Reservamos memoria dinámica para la imagen */
imageA = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageA[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Reservamos memoria dinámica para la imagen */
imageB = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageB[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Leemos la imagen A de disco */
readOK = pgmRead (argv[1],&rowsA,&colsA,imageA);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[1]);
exit(1);
}
/* Leemos la imagen B de disco */
readOK = pgmRead (argv[2],&rowsB,&colsB,imageB);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[2]);
exit(1);
}
for(i=0;i<rowsA;i++)
{
for(j=0;j<colsA;j++)
{
//imageA[i][j] = (imageA[i][j] + imageB[i][j])/2;
imageA[i][j] = (unsigned char)((imageA[i][j]*0.5) + (imageB[i][j]*0.5));
/*int aux = imageA[i][j] + imageB[i][j] - 128;
if (aux > 255)
{
imageA[i][j] = 255;
}
else
{
if (aux < 0)
{
imageA[i][j] = 0;
}
else
{
imageA[i][j] = aux;
}
}*/
}
}
/* Guardamos la imagen en disco */
writeOK = pgmWrite(argv[3],rowsA,colsA,imageA,NULL);
if (writeOK)
{
printf("\nEl archivo: %s, se ha creado con éxito.\n",argv[3]);
}
else
{
printf("\nError al crear la imagen: %s.\n",argv[3]);
}
return 0;
}
int main (int argc, char *argv[])
{
long rowsA, colsA; /* Dimensiones de la imagen A */
long rowsB, colsB; /* Dimensiones de la imagen B */
unsigned char **imageA; /* Array 2D para la imagen A */
unsigned char **imageB; /* Array 2D para la imagen B */
int readOK, writeOK; /* Controlan la E/S de disco */
precint *precinctsIn; /* Vector de precintos de entrada*/
long npIn; /* Numero de elementos del vector de entrada */
precint *precinctsOut; /* Vector de precintos de salida*/
long precinctSize; /* Tamaño del precinto */
long i, j, k;
unsigned char diff;
double sumaMSE;
/* Comprobamos el número de parametros */
if (argc!=6)
{
printf("\nUso: %s <in_filename_precincts_list_txt> <in_filenameA> <in_filenameB> <precinct_size> <out_filename_precincts_list>.",argv[0]);
printf("\n\nin_filename_precincts_list = Lista de precintos de entrada.");
printf("\nin_filenameA = Image PGM.");
printf("\nin_filenameB = Image PGM.");
printf("\nprecinct_size = [16,4096].");
printf("\nout_filename_precincts_list = Precincts list.\n\n");
exit(0);
}
/* Validamos el valor del tamaño de precinto */
precinctSize = atoi(argv[4]);
/*if (precinctSize<16 || precinctSize>4096 || precinctSize%2!=0)
{
printf("\nEl valor de precint_size debe un múltiplo de 2 entre [16,4096].\n");
exit(0);
}*/
/* Reservamos memoria dinámica para la imagen */
imageA = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageA[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Reservamos memoria dinámica para la imagen */
imageB = ( unsigned char** )malloc( MAXROWS*sizeof( unsigned char* ) );
/* Reservamos memoria para cada fila */
for(i = 0; i < MAXROWS; i++)
{
imageB[i] = ( unsigned char* )malloc( MAXCOLS*sizeof( unsigned char ) );
}
/* Leemos la imagen A de disco */
readOK = pgmRead (argv[2],&rowsA,&colsA,imageA);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[2]);
exit(1);
}
/* Leemos la imagen B de disco */
readOK = pgmRead (argv[3],&rowsB,&colsB,imageB);
if (!readOK)
{
printf("\nError al abrir la imagen: %s.\n",argv[3]);
exit(1);
}
/* Comprobamos que las dos imágenes tienen las mismas dimensiones */
if (rowsA==rowsB && colsA==colsB)
{
/* Calculamos el numero de precintos que contiene la imagen */
npIn = (rowsA/precinctSize)*(colsA/precinctSize);
/* Reservamos memoria dinámica para el vector de precintos */
precinctsIn = (precint *) malloc (npIn*sizeof(precint));
precinctsOut = (precint *) malloc (npIn*sizeof(precint));
/* Leemos el vector de precintos sobre el que vamos a calcular las diferencias */
readOK = readPrecinctsFromFileTXT(precinctsIn, &npIn, argv[1]);
if (!readOK)
{
printf("\nError al abrir el archivo de precintos: %s.\n",argv[1]);
exit(1);
}
for(i=0;i<npIn;i++)
{
/* Calculamos el MSE para cada precinto */
/* Restamos píxel a píxel los precintos de la imagen A con la imagen B */
sumaMSE = 0;
for(j=precinctsIn[i].offsetx;j<(precinctsIn[i].offsetx + precinctSize);j++)
{
for(k=precinctsIn[i].offsety;k<(precinctsIn[i].offsety + precinctSize);k++)
{
diff = (unsigned char)(((int)imageA[j][k] - (int)imageB[j][k]))+128;
sumaMSE = sumaMSE + ((diff-128)*(diff-128));
}
}
//printf("[%d] %lf. PrecintSize: %ld, MSE: %lf\n", i, sumaMSE, precinctSize, sumaMSE/(precinctSize*precinctSize));
/* Generamos el vector de precintos con las diferencias */
precinctsOut[i].offsetx = precinctsIn[i].offsetx;
precinctsOut[i].offsety = precinctsIn[i].offsety;
precinctsOut[i].countDifferences = sumaMSE/(precinctSize*precinctSize);
}
/* Ordenamos el vector de precintos */
OrdenarSeleccionDirecta(precinctsOut,npIn);
/* Imprimimos la lista de precintos */
printPrecinctsList(precinctsOut,npIn);
/* Guardamos la lista de precintos en disco */
writeOK = writePrecinctsToFile(precinctsOut,npIn,argv[5]);
if (writeOK)
{
printf("\nEl archivo: %s, con la lista de precintos se ha creado con éxito.",argv[5]);
}
else
{
printf("\nError al crear el archivo de precintos: %s.",argv[5]);
}
}
else
{
printf("\nLas imágenes no tienen las mismas dimensiones.\n");
}
/* Liberamos la memoria usada por las imágenes */
deallocate2D(imageA,MAXROWS);
deallocate2D(imageB,MAXROWS);
return 0;
}
