void
layout_resize(int winc, int hinc) {
Win *w;
List *l, *ll;
Layout *lo;
Laydata *ld;
int x, y, width, height;
unsigned int i, j;
if(!data.current || !(lo = layout_get(var.layout)))
return;
i = win_index(data.tag, NORMAL, data.current);
j = win_len(data.tag, NORMAL) - 1;
x = y = width = height = 0;
if(win_first(data.tag, NORMAL, &l, &w))
for(;w;) {
if(!(l = list_nth(lo->data, i)))
l = list_last(lo->data);
j = lo->tile ? MIN(list_len(l), j) : j;
l = (List*)l->ptr;
if(!(ll = list_nth(l, (j - i))))
ll = list_last(l);
ld = (Laydata*)ll->ptr;
if(!x && !y && !width && !height) {
x = ld->x;
y = ld->y;
width = ld->width;
height = ld->height;
if(height >= 100)
hinc = 0;
if(width >= 100)
winc = 0;
i = 0;
continue;
}
resize(x, width, &ld->x, (int*)&ld->width, winc);
resize(y, height, &ld->y, (int*)&ld->height, hinc);
win_next(data.tag, NORMAL, &l, &w);
++i;
}
layout_arrange();
}
/*=*/ int A_menos_x_contido_W (trv_struc * base, win_struc * win) {
/* colocar win no formato de base->B se win esta contido */
/* em base->win */
win_struc win1, win2;
int * A, tam_A, i, contido, ind;
int nshifts, block, win_nshifts, section;
int * winidx, * base_A, * base_B;
if (base == NULL || win == NULL) {
fprintf (stderr, "A_menos_x_contido_W () pointers to NULL\n");
return 0;
}
if (base->size != 1) {
fprintf (stderr, "The basis must represent just one interval\n");
return 0;
}
copy_win (&base->win, &win1);
copy_win (win, &win2);
/* colocar win e base->win em um mesmo tamanho de retangulo */
if (win1.hsize < win2.hsize)
transform_to_big_window (&win1, win2.hsize);
else
transform_to_big_window (&win2, win1.hsize);
/* monta o lado esquerdo do intervalo no tamanho do retangulo da janela */
tam_A = (win1.hsize*win1.wsize+NB1)/NB;
A = (int *) node_allocation (sizeof (int)*tam_A);
for (i=0; i<tam_A; i++) A[i] = 0;
win_index (&win1, &winidx);
ind = base->ind[0]; /* ind must be equal to zero */
base_A = &base->A[ind];
for (i=0; i<base->nv; i++) {
nshifts = i%NB;
block = i/NB;
if ((base_A[block] & mask[nshifts]) != 0) {
win_nshifts = winidx[i]%NB;
section = winidx[i]/NB;
A[section] |= mask[win_nshifts];
}
}
/* A e' o lado esquerdo do intervalo no retangulo da janela */
if (winidx) free (winidx);
winidx = NULL;
/* verifica se o lado esquerdo esta' contido na janela W */
contido=1;
for (i=0; i<tam_A && contido; i++) {
if ((A[i] & win2.data[i]) != A[i]) {
contido=0;
break;
}
}
/* liberando a base antiga */
free_basis_by_ron (base);
if (contido) {
/* atualizando os novos parametros da base */
/* Esta base vai estar definida na janela W */
base->nv = win2.size;
base->nb = (win2.size+NB1)/NB;
base->total = base->size = 1;
base->A = (int *) node_allocation (sizeof(int)*base->total*base->nb);
base->B = (int *) node_allocation (sizeof(int)*base->total*base->nb);
base->ind = (int *) node_allocation (sizeof(int)*base->total);
base->ind[0] = 0;
copy_win (&win2, &base->win);
base_A = &base->A[0];
base_B = &base->B[0];
/* novos indices da janela win */
if (winidx) free (winidx);
win_index (&win2, &winidx);
/* montando o lado esquerdo e direito do intervalo da base */
for (i=0; i<base->nb; i++) base_A[i] = base_B[i] = 0;
for (i=0; i<base->nv; i++) {
win_nshifts = winidx[i]%NB;
section = winidx[i]/NB;
if (((~A[section]) & mask[win_nshifts]) != 0) {
nshifts = i%NB;
block = i/NB;
base_B[block] |= mask[nshifts];
}
if ((A[section] & mask[win_nshifts]) != 0) {
nshifts = i%NB;
block = i/NB;
base_A[block] |= mask[nshifts];
}
}
}
if (A) free (A);
if (winidx) free (winidx);
free_win_by_ron (&win1);
free_win_by_ron (&win2);
return 1;
}
/*=*/ int B_menos_x_contido_W (trv_struc * base, win_struc * win) {
/* colocar win no formato de base->B se win esta contido */
/* em base->win */
win_struc win1, win2;
int * B, tam_B, i, contido, ind;
int nshifts, block, win_nshifts, section;
int * winidx, * base_A, * base_B;
int j, tem;
if (base == NULL || win == NULL) {
fprintf (stderr, "A_menos_x_contido_W () pointers to NULL\n");
return 0;
}
if (base->size != 1) {
fprintf (stderr, "The basis must represent just one interval\n");
return 0;
}
copy_win (&base->win, &win1);
copy_win (win, &win2);
/* colocar win e base->win em um mesmo tamanho de retangulo */
if (win1.hsize < win2.hsize)
transform_to_big_window (&win1, win2.hsize);
else
transform_to_big_window (&win2, win1.hsize);
/* monta o lado esquerdo do intervalo no tamanho do retangulo da janela */
tam_B = (win1.hsize*win1.wsize+NB1)/NB;
B = (int *) node_allocation (sizeof (int)*tam_B);
for (i=0; i<tam_B; i++) B[i] = 0;
win_index (&win1, &winidx);
ind = base->ind[0]; /* ind must be equal to zero */
base_B = &base->B[ind];
for (i=0; i<base->nv; i++) {
nshifts = i%NB;
block = i/NB;
if ((base_B[block] & mask[nshifts]) != 0) {
win_nshifts = winidx[i]%NB;
section = winidx[i]/NB;
B[section] |= mask[win_nshifts];
}
}
/* invertendo B */
for (i=0; i<tam_B; i++) B[i] = ~B[i];
/* B e' o lado direito do intervalo no retangulo da janela */
if (winidx) free (winidx);
win_index (&win2, &winidx);
contido = 1; /* se terminar com 1, continua, senao cai fora */
/* se W[i] == 0 entao B[i] == 1 */
for (i=0; i<win->hsize*win->wsize; i++) {
for (j=0, tem=0; j<win->size && !tem; j++) {
if (i==winidx[j]) tem = 1;
}
/* neste caso, o valor de W no ponto e' zero */
if (!tem) {
win_nshifts = i%NB;
section = i/NB;
if ( (B[section] & mask[win_nshifts]) == 0 ) {
contido = 0;
break;
}
}
}
/* liberando a base antiga */
free_basis_by_ron (base);
if (contido) {
/* fazendo a interseccao */
for (i=0; i<tam_B; i++) B[i] = (B[i] & win2.data[i]);
/* faz a negacao do lado direito */
for (i=0; i<tam_B; i++) B[i] = ~B[i];
/* atualizando os novos parametros da base */
/* Esta base vai estar definida na janela W */
base->nv = win2.size;
base->nb = (win2.size+NB1)/NB;
base->total = base->size = 1;
base->A = (int *) node_allocation (sizeof(int)*base->total*base->nb);
base->B = (int *) node_allocation (sizeof(int)*base->total*base->nb);
base->ind = (int *) node_allocation (sizeof(int)*base->total);
base->ind[0] = 0;
copy_win (&win2, &base->win);
base_A = &base->A[0];
base_B = &base->B[0];
/* novos indices da janela win */
if (winidx) free (winidx);
win_index (&win2, &winidx);
/* montando o lado esquerdo e direito do intervalo da base */
for (i=0; i<base->nb; i++) base_A[i] = base_B[i] = 0;
for (i=0; i<base->nv; i++) {
win_nshifts = winidx[i]%NB;
section = winidx[i]/NB;
if (((B[section]) & mask[win_nshifts]) != 0) {
nshifts = i%NB;
block = i/NB;
base_B[block] |= mask[nshifts];
}
if ((~B[section] & mask[win_nshifts]) != 0) {
nshifts = i%NB;
block = i/NB;
base_A[block] |= mask[nshifts];
}
}
}
if (B) free (B);
if (winidx) free (winidx);
free_win_by_ron (&win1);
free_win_by_ron (&win2);
return 1;
}
/*=*/ int search_increasing_all_direto (trv_struc * base, output_search * * sai) {
trv_struc minimo;
win_struc S, C;
int * comb, num_comb, tam_idx, *winidx, i, j, k, tem;
int section, nshifts, tam, invariante;
mat_str str;
trv_struc_list * lower;
win_struc_list * Lista_C, * apt_Lista_C;
int tam_Lista_C;
output_search * apt_sai;
trv_struc_list * apt_trv, * solucao;
zera_basis_by_ron (&minimo);
zera_win_by_ron (&S);
zera_win_by_ron (&C);
str.dat = NULL;
Lista_C = NULL;
*sai = NULL;
// disp_basis_by_ron (base);
minimo_lado_esquerdo (&minimo, base);
// printf ("Base Total = %d\n", base->total);
// disp_basis_by_ron (&minimo);
esse_min_lado_esquerdo_min (&S, &minimo, base);
// printf ("Menor Elemento Estruturante: N. de Pontos = %d\n", S.size);
// disp_win_by_ron (&S);
win_index (&S, &winidx);
tam_idx = S.size;
copy_win (&S, &C);
tam = (S.hsize*S.wsize + NB1) / NB;
tam_Lista_C = 0;
for (i=1; i<=tam_idx; i++) {
comb = NULL; num_comb = numero_de_combinacoes (tam_idx, i);
for (j=0; j<num_comb; j++) {
_combinacoes_ (tam_idx, i, &comb);
if (i>1) {
for (k=0; k<tam; k++) C.data[k] = 0;
C.size = 0;
for (k=0; k<i; k++) {
section = winidx[comb[k]] / NB;
nshifts = winidx[comb[k]] % NB;
C.data[section] |= mask[nshifts];
(C.size)++;
}
/* Neste ponto temos um C gerado */
/* verifica se C e' invariante de S */
invariante = invariante_window (&S, &C);
if (invariante) {
tem = 0;
for (apt_Lista_C = Lista_C; apt_Lista_C && !tem; apt_Lista_C =
apt_Lista_C->prox) {
if (C.size == apt_Lista_C->win.size) {
tem = invariante_window (&C, &apt_Lista_C->win);
}
}
if (!tem) {
apt_Lista_C = (win_struc_list *)
node_allocation (sizeof(win_struc_list));
copy_win (&C, &apt_Lista_C->win);
apt_Lista_C->prox = Lista_C;
Lista_C = apt_Lista_C;
tam_Lista_C++;
}
}
}
}
if (comb) free (comb);
}
/*
printf ("Elementos Estruturantes\n");
for (apt_Lista_C = Lista_C; apt_Lista_C; apt_Lista_C = apt_Lista_C->prox) {
printf ("Structuring Element:\n");
disp_win_by_ron (&apt_Lista_C->win);
printf ("\n");
}
printf ("FIM: Elementos Estruturantes\n");
*/
// printf ("Base = %d\n", base->total);
// printf ("Menor Elemento Estruturante: N. de Pontos = %d\n", S.size);
// disp_win_by_ron (&S);
// if (Lista_C) printf ("Lista_C nao vazia\n");
// else printf ("Lista_C vazia\n");
while (Lista_C) {
apt_Lista_C = Lista_C;
Lista_C = Lista_C->prox;
if (str.dat) {free (str.dat); str.dat = NULL;}
window_to_str (&apt_Lista_C->win, &str);
if (beatriz) {
printf ("Structuring Element:\n");
disp_win_by_ron (&apt_Lista_C->win);
printf ("\n");
}
if (leZ)
le_os_Z ("Z.txt", &lower);
else
gera_lower_bounds_crescente (&lower, base, &str);
testa_equacao_dilatacao_crescente (base, &str, lower, &solucao);
apt_sai = (output_search *) node_allocation (sizeof(output_search));
copy_win (&apt_Lista_C->win, &apt_sai->C);
apt_sai->list_base = solucao;
apt_sai->prox = * sai;
* sai = apt_sai;
free_win_by_ron (&apt_Lista_C->win);
free (apt_Lista_C);
}
free_basis_by_ron (&minimo);
free_win_by_ron (&S);
free_win_by_ron (&C);
if (winidx) free (winidx);
if (str.dat) free (str.dat);
return 1;
}
