double runAlgorithmCholesky(double **inputMatrix, double *b, int size, double *x) {
double **factorizedMatrix = allocate2DArray(size, size);
double **factorizedMatrixTrans = allocate2DArray(size, size);
double *y = allocade1DArray(size);
double timeConsumed = 0;
time_t start = time(NULL);//POMIAR CZASU START
cholesky(size, inputMatrix, factorizedMatrix);
//printf("Sfaktoryzowana macierz Choleskiego (U): \n");
//print2DArray(factorizedMatrix, size, size);
matrixTransposition(size, factorizedMatrix, factorizedMatrixTrans);
//printf("Sfaktoryzowana transponowana macierz Choleskiego (U): \n");
//print2DArray(factorizedMatrixTrans, size, size);
forwardSolutionPhase(size, factorizedMatrixTrans, b, y);
//printf("\nWynik po forwardSolutionPhase: \n");
//print1DArray(y, size);
backwardSolutionPhase(size, factorizedMatrix, y, x);
//printf("\nWynik po backwardSolutionPhase: \n");
//print1DArray(x, size);
timeConsumed = (double)(time(NULL) - start);//POMIAR CZASU END
//printf("\nSprawdzenie rozwiązania: \n");
//checkSolution(inputMatrix, x, b, size);
deallocate2D(factorizedMatrix,size);
deallocate2D(factorizedMatrixTrans,size);
free(y);
return timeConsumed;
}
void multigrid(int m, /* Malla en la que estamos */
double ***d, /* Defecto */
double ***v,
int iteraciones_s1,
int iteraciones_s2,
const char * tipo) /* tipo de suavizador */
{
int d_malla; /* dimension de la malla */
int d_malla_inf; /* dimension de la malla inferior */
double **fu;
double **vg;
if(m==0)
{
exacta(d[m],v[m]);
printf("Exacta");
}
else
{
d_malla=pow(2,m+1)+1;
d_malla_inf=pow(2,m)+1;
inicializa_cero(v[m],d_malla);
fu=allocate2D(d_malla,d_malla);
vg=allocate2D(d_malla,d_malla);
copia_matriz(d[m],fu,d_malla);
suaviza(v[m],fu,iteraciones_s1,tipo,d_malla);
copia_matriz(v[m],vg,d_malla);
calcula_defecto(d[m],fu,v[m],d_malla);
///muestra_matriz("d",d[m],d_malla,d_malla);
restringe(d[m],d[m-1],d_malla_inf);
multigrid(m-1,d,v,iteraciones_s1,iteraciones_s2,tipo);
interpola(v[m-1],v[m],d_malla_inf,d_malla);
suma_matrices(v[m],vg,d_malla);
suaviza(v[m],fu,iteraciones_s2,tipo,d_malla);
deallocate2D(fu,d_malla);
deallocate2D(vg,d_malla);
}
}
int main(int argc,char *argv[])
{
int i,j;
int n_mallas=4;
int iteraciones_s1=1; /* Iteraciones del primer suavizador */
int iteraciones_s2=1; /* Iteraciones del segundo suavizador */
int dimension;
int dim_inf; /* Dimension de la malla inferior */
double norma_defecto=1.0;
double norma_defecto_anterior;
double **u; /* Solución */
double **f;
double ***v;
double ***d;
const char *tipo="gsrb";
const char *uso="\n";
///////////////////////////////////////////
// escaneo de argumentos //
if((argc>1) && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
printf (uso, argv[0]);
exit(1);
}
for(i=1;i<argc;i++)
{
if(!strcmp(argv[i],"-mallas"))
{
n_mallas=atoi(argv[++i]);
}
else
{
fprintf(stderr,"Opción inválida '%s'\n `%s --help` para mas información\n",
argv[i], argv[0]);
exit(1);
}
}
// Fin escaneo de argumentos //
///////////////////////////////////////////
///////////////////////////////////////////
// Generamos los datos necesarios //
// //
// x . x . x //
// . . . . . //
// x . x . x //
// . . . . . //
// x . x . x n_mallas=2, dimension=5 //
dimension = pow(2,n_mallas)+1;
u=allocate2D(dimension,dimension);
f=allocate2D(dimension,dimension);
inicializa_cero(f,dimension);
//muestra_matriz("f",f,dimension,dimension);
inicializa(u,dimension);
//muestra_matriz("u",u,dimension,dimension);
v=(double***)malloc(n_mallas*sizeof(double**)); // v y d son matrices p
d=(double***)malloc(n_mallas*sizeof(double**)); // en cada malla
for(i=0;i<n_mallas;i++)
{
j=pow(2,i+1)+1;
v[i]=allocate2D(j,j);
d[i]=allocate2D(j,j);
inicializa_cero(v[i],j);
inicializa_cero(d[i],j);
//muestra_matriz("v",v[i],j,j);
}
// Fin inicialización //
////////////////////////////////////////////
////////////////////////////////////////////
// Bucle principal //
for(i=0;i<20;i++)
{
dim_inf=(dimension+1)/2;
/* Suavizado */
suaviza(u,f,iteraciones_s1,tipo,dimension);
//muestra_matriz("u",u,dimension,dimension);
/* Cálculo del defecto */
calcula_defecto(d[n_mallas-1],f,u,dimension);
//muestra_matriz("d",d[n_mallas-1],dimension,dimension);
/* Restringimos el defecto */
restringe(d[n_mallas-1],d[n_mallas-2],(dimension+1)/2);
//muestra_matriz("d_",d[n_mallas-2],(dimension+1)/2,(dimension+1)/2);
/* Llamamos a multigrid */
multigrid(n_mallas-2,d,v,iteraciones_s1,iteraciones_s2,tipo);
//muestra_matriz("v_",v[n_mallas-2],(dimension+1)/2,(dimension+1)/2);
/* Interpolamos */
interpola(v[n_mallas-2],v[n_mallas-1],(dimension+1)/2,dimension);
//muestra_matriz("v",v[n_mallas-1],dimension,dimension);
/* Sumamos */
suma_matrices(u,v[n_mallas-1],dimension);
//muestra_matriz("u",u,dimension,dimension);
/* Volvemos a suavizar */
suaviza(u,f,iteraciones_s2,tipo,dimension);
//muestra_matriz("u",u,dimension,dimension);
/* Comienza el test de convergencia */
calcula_defecto(d[n_mallas-1],f,u,dimension);
//muestra_matriz("d",d[n_mallas-1],dimension,dimension);
norma_defecto_anterior=norma_defecto;
norma_defecto=calcula_max(d[n_mallas-1],dimension);
printf("Iter: %d max(defecto)=%e\tratio=%0.10f\n",i,norma_defecto,norma_defecto/norma_defecto_anterior);
}
// Fin bucle principal //
////////////////////////////////////////////
////////////////////////////////////////////
// Liberamos memoria //
deallocate2D(u,dimension);
deallocate2D(f,dimension);
for(i=0;i<n_mallas;i++)
{
j=pow(2,i+1)+1;
deallocate2D(v[i],j);
deallocate2D(d[i],j);
}
free(v);
free(d);
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;
}
