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;
}
int main(int argc, char *argv[])
{
offset *lista;
offset *distintos;
long ne, nedis;
double sum;
int readOK, writeOK;
if (argc != 3)
{
printf("\nUso: %s <in_offset_list> <out_distinct_offset_list>\n",argv[0]);
printf("\nDescripción: ");
printf("\n Acepta una lista de offsets y devuelve la misma lista sin elementos repetidos.\n");
printf("\nParámetros: ");
printf("\n - <in_offset_list> = Archivo de entrada con la lista de offsets.");
printf("\n - <out_offset_list> = Archivo de salida con la lista de offsets.\n\n");
exit(1);
}
/* Contamos el numero de elementos de la lista para reservar memoria */
ne = NumeroDeOffsetList(argv[1]);
if (!ne)
{
printf("\nError al abrir el archivo: %s.",argv[1]);
exit(1);
}
/* Reservamos memoria dinámica para los vectores de offsets */
lista = (offset *) malloc (ne*sizeof(offset));
distintos = (offset *) malloc (ne*sizeof(offset));
/* Leemos el archivo de offsets */
readOK = LeerOffsetList(argv[1],lista,&ne);
if (!readOK)
{
printf("\nError al abrir el archivo: %s.",argv[1]);
exit(1);
}
//qsort(lista, ne, sizeof(offset), &compare);
/* Creamos una lista con los paquetes que no se repiten */
EliminarRepetidosOne(lista,ne,distintos,&nedis);
printf("\n# Paquetes total: %ld",ne);
printf("\n# Paquetes distintos: %ld",nedis);
printf("\n# Paquetes repetidos: %ld",ne-nedis);
/* Sumamos los bytes de los paquetes distintos */
sum = SumBytes(distintos,nedis);
printf("\nSum (Bytes): %lf",sum);
printf("\nSum (KBytes): %lf",sum/1024);
printf("\nSum (MBytes): %lf\n",sum/(1024*1024));
printf("\nBYTES: %.0lf",sum);
/* Ordenamos la lista ascendentemente según el offset */
OrdenarSeleccionDirecta(distintos,nedis);
/* Guardamos la nueva lista de offset sin elementos repetidos */
writeOK = EscribirOffsetList(argv[2],distintos,nedis);
if (!writeOK)
{
printf("\nError al crear el archivo: %s.",argv[2]);
exit(1);
}
return 0;
}
int main (int argc, char *argv[])
{
precint *precinctsUp;
precint *precinctsDown;
precint *precinctsOut;
long npUp;
long npDown;
long i, j;
int readOK, writeOK;
if (argc!=4)
{
printf("\nUso: %s <in_filename_precincts_list_A_dat> <in_filename_precincts_list_B_dat> <out_filename_precincts_dat>.\n\n",argv[0]);
exit(0);
}
/* Reservamos memoria dinámica para los vectores de precintos */
precinctsUp = (precint *) malloc (MAX*sizeof(precint));
precinctsDown = (precint *) malloc (MAX*sizeof(precint));
precinctsOut = (precint *) malloc (2*MAX*sizeof(precint));
readOK = readPrecinctsToFile(precinctsUp, &npUp, argv[1]);
if (!readOK)
{
printf("\nError al abrir el archivo: %s.\n",argv[1]);
exit(1);
}
readOK = readPrecinctsToFile(precinctsDown, &npDown, argv[2]);
if (!readOK)
{
printf("\nError al abrir el archivo: %s.\n",argv[2]);
exit(1);
}
for(i=0;i<npUp;i++)
{
precinctsOut[i] = precinctsUp[i];
}
for(j=0;j<npDown;j++)
{
precinctsOut[i] = precinctsDown[j];
i++;
}
OrdenarSeleccionDirecta(precinctsOut, i);
writeOK = writePrecinctsToFile(precinctsOut, i, argv[3]);
if (!writeOK)
{
printf("\nError al abrir el archivo: %s.\n",argv[3]);
exit(1);
}
else
{
printf("\nEl archivo: %s se creó con éxito.\n",argv[3]);
}
return 0;
}
