void filtroMediana(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas, int larguraJanela) {
int v_array[256];
int m_copy[MAXLINHA][MAXCOLUNA];
int i, j, a, b, pos;
int xsup, ysup, xinf, yinf;
int offset = (larguraJanela - 1) / 2;
copia_matriz(m, m_copy, linhas, colunas);
for (i = 0; i < 256; i++)
v_array[i] = 0;
for (i = 0; i < linhas; i++) {
for (j = 0; j < colunas; j++) {
xsup = max(0, j - offset);
ysup = max(0, i - offset);
xinf = min(colunas - 1, j + offset);
yinf = min(linhas - 1, i + offset);
pos = 0;
/* Procuro a mediana no meu vetor ordenado. */
for(a = ysup; a <= yinf; a++) {
for(b = xsup; b <= xinf; b++) {
v_array[pos++] = m_copy[a][b];
}
}
mergesort(v_array, 0, pos);
m[i][j] = v_array[pos/2];
}
}
}
int main()
{
//Constantes
char const nome_arquivo[] = "./6ex_matriz.txt";
//Inicializa variaveis
float matrizBuffer[100][100];
int iA, jA;
//Le a matriz A do arquivo para um buffer
le_matriz(nome_arquivo, matrizBuffer, &iA, &jA);
if(iA != jA)
{
printf("A matriz fornecida nao e quadrada, como propoe o problema");
exit(1);
}
//Agora que conhece o tamanho inicializa a matriz
float matrizA[iA][jA];
//E em seguida copia os valores
copia_matriz(matrizBuffer, iA, jA, matrizA);
//Verifica se a matriz é simetrica
verifica_simetria(iA, jA, matrizA);
}
void filtroBorda3(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas, int larguraJanela, int k) {
int aux[MAXLINHA][MAXCOLUNA];
copia_matriz(m, aux, linhas, colunas);
filtroDilatacao(m, linhas, colunas, larguraJanela);
subtracao_matriz(m, aux, linhas, colunas);
limiarizacao(m, linhas, colunas, k);
}
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);
}
}
void filtroDilatacao(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas, int larguraJanela) {
int m_copy[MAXLINHA][MAXCOLUNA];
int i, j, a, b, max_value;
int xsup, ysup, xinf, yinf;
int offset = (larguraJanela - 1) / 2;
copia_matriz(m, m_copy, linhas, colunas);
for (i = 0; i < linhas; i++) {
for (j = 0; j < colunas; j++) {
xsup = max(0, j - offset);
ysup = max(0, i - offset);
xinf = min(colunas - 1, j + offset);
yinf = min(linhas - 1, i + offset);
max_value = -1;
for(a = ysup; a <= yinf; a++)
for(b = xsup; b <= xinf; b++)
max_value = max(max_value, m_copy[a][b]);
m[i][j] = max_value;
}
}
}
void filtroMedia(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas, int larguraJanela) {
int m_copy[MAXLINHA][MAXCOLUNA];
int i, j, a, b, sum;
int xsup, ysup, xinf, yinf;
int offset = (larguraJanela - 1) / 2;
copia_matriz(m, m_copy, linhas, colunas);
for (i = 0; i < linhas; i++) {
for (j = 0; j < colunas; j++) {
xsup = max(0, j - offset);
ysup = max(0, i - offset);
xinf = min(colunas - 1, j + offset);
yinf = min(linhas - 1, i + offset);
sum = 0;
for(a = ysup; a <= yinf; a++)
for(b = xsup; b <= xinf; b++)
sum += m_copy[a][b];
m[i][j] = sum / ((xinf - xsup + 1) * (yinf - ysup + 1));
}
}
}
void multigrid(malla * u, malla *f, matriz *op, double * max)
{
int i,j;
if(u->nivel==1)
{
/* Escalar el operador al nivel */
matriz op_n;
/* Inicializamos el operador */
inicializa_matriz(&op_n,3);
copia_matriz(op,&op_n);
escala_matriz(&op_n,pow((u->dimension-1),2));
/* Construimos el sistema a resolver */
double A[3][3];
A[0][0]=op_n.v[1][1];
A[0][1]=op_n.v[2][1];
A[0][2]=op_n.v[2][2];
A[1][0]=op_n.v[0][1];
A[1][1]=op_n.v[1][1];
A[1][2]=op_n.v[1][2];
A[2][0]=op_n.v[0][0];
A[2][1]=op_n.v[1][0];
A[2][2]=op_n.v[1][1];
double B[3];
B[0] = f->v[2][1]-op_n.v[1][2]*u->v[2][2]
-op_n.v[0][1]*u->v[1][1]
-op_n.v[0][0]*u->v[1][0]
-op_n.v[1][0]*u->v[2][0];
B[1] = f->v[3][1]-op_n.v[0][0]*u->v[2][0]
-op_n.v[1][0]*u->v[3][0]
-op_n.v[2][1]*u->v[4][1];
B[2] = f->v[3][2]-op_n.v[0][1]*u->v[2][2]
-op_n.v[1][2]*u->v[3][3]
-op_n.v[2][2]*u->v[4][3]
-op_n.v[2][1]*u->v[4][2];
/* Hacemos eliminación gausiana */
A[1][1]=A[1][1]-A[0][1]*A[1][0]/A[0][0];
A[1][2]=A[1][2]-A[0][2]*A[1][0]/A[0][0];
B[1]=B[1]-B[0]*A[1][0]/A[0][0];
A[2][1]=A[2][1]-A[0][1]*A[2][0]/A[0][0];
A[2][2]=A[2][2]-A[0][2]*A[2][0]/A[0][0];
B[2]=B[2]-B[0]*A[2][0]/A[0][0];
A[2][2]=A[2][2]-A[1][2]*A[2][1]/A[1][1];
B[2]=B[2]-B[1]*A[2][1]/A[1][1];
/* Resolvemos */
u->v[3][2]=B[2]/A[2][2];
u->v[3][1]=(B[1]-A[1][2]*u->v[3][2])/A[1][1];
u->v[2][1]=(B[0]-A[0][2]*u->v[3][2]-A[0][1]*u->v[3][1])/A[0][0];
}
else
{
/* Escalar el operador al nivel */
matriz op_n;
/* Definicion de las mallas */
malla d; /* Para almacenar el defecto */
malla d_; /* Para almacenar el defecto restringido */
malla v;
malla v_;
/* Inicializacióm mallas*/
inicializa_malla_c(&d,u->nivel);
inicializa_malla_c(&d_,u->nivel-1);
inicializa_malla_c(&v,u->nivel);
inicializa_malla_c(&v_,u->nivel-1);
inicializa_matriz(&op_n,3);
copia_matriz(op,&op_n);
printf("sf=pow(%d,2)",u->dimension-1);
escala_matriz(&op_n,pow((u->dimension-1),2));
/* Suavizado */
muestra_malla(u);
printf("After smooth %f\n ",op_n.v[1][1]);
suaviza_r(u,f,&op_n);
suaviza_g(u,f,&op_n);
suaviza_b(u,f,&op_n);
muestra_malla(u);
/* Defecto */
defecto(u,f,&d,&op_n);
printf("After defect %f\n ",op_n.v[1][1]);
muestra_malla(&d);
/* Restringimos */
restringe(&d,&d_);
/* Rellamada a multigrid */
multigrid(&v_,&d_,op,max);
/* Interpolamos */
interpola(&v_,&v);
/* Sumamos */
suma_mallas(u,&v);
/* Postsuavizamos */
suaviza_r(u,f,&op_n);
suaviza_g(u,f,&op_n);
suaviza_b(u,f,&op_n);
/* En la malla mas alta, comprobamos cómo va la cosa */
if(u->nivel==2)
{
/* Calculamos el defecto */
defecto(u,f,&d,&op_n);
for(i=0;i<u->dimension;i++)
{
for(j=0;j<i;j++)
{
if(fabs(d.v[i][j])>max[0])
{
max[0]=fabs(d.v[i][j]);
}
}
}
}
/* Liberacion de recursos */
libera_matriz(&op_n);
libera_malla(&d);
libera_malla(&d_);
libera_malla(&v);
libera_malla(&v_);
}
}
