static int compare_wind(const struct Cell_head *savedwin,
const struct Cell_head *curwin)
{
float e_ings[4], n_ings[4], area_lap, area_saved;
int outside = 0;
if (savedwin->north < curwin->south)
outside = 1;
if (savedwin->south > curwin->north)
outside = 1;
if (savedwin->east < curwin->west)
outside = 1;
if (savedwin->west > curwin->east)
outside = 1;
if (outside)
return (0);
e_ings[0] = savedwin->west;
e_ings[1] = savedwin->east;
e_ings[2] = curwin->west;
e_ings[3] = curwin->east;
edge_sort(e_ings);
n_ings[0] = savedwin->south;
n_ings[1] = savedwin->north;
n_ings[2] = curwin->south;
n_ings[3] = curwin->north;
edge_sort(n_ings);
area_lap = (e_ings[2] - e_ings[1]) * (n_ings[2] - n_ings[1]);
area_saved = (savedwin->east - savedwin->west) *
(savedwin->north - savedwin->south);
return ((int)(area_lap * 100.0 / area_saved));
}
int vertex_compress(float vertex[][3],
int vertex_used[],
int edge_top, int edge[][3],
int triangle_top, int triangle[][4], float triangle_normal[][3],
int group[])
{
int p[VERTEX_MAX];
int i, first_unused=0, last_used=VERTEX_MAX-1;
for(i=0; i<VERTEX_MAX; i++) p[i]=i;
while(first_unused<=last_used)
{
while(first_unused<= last_used && vertex_used[first_unused]>0) first_unused++;
while(last_used>=first_unused && vertex_used[last_used]<=0) last_used--;
if(first_unused<last_used)
{
p[last_used]=first_unused;
vectorcpy(vertex[first_unused], vertex[last_used]);
vertex_used[first_unused]=vertex_used[last_used];
group[first_unused]=group[last_used];
vertex_used[last_used]=0;
}
}
for(i=0; i<edge_top; i++)
{
edge[i][0]=p[edge[i][0]];
edge[i][1]=p[edge[i][1]];
edge_sort(edge[i]);
}
for(i=0; i<triangle_top; i++)
{
triangle[i][0]=p[triangle[i][0]];
triangle[i][1]=p[triangle[i][1]];
triangle[i][2]=p[triangle[i][2]];
triangle_sort(triangle[i]);
triangle_normal_vector( vertex[triangle[i][0]],
vertex[triangle[i][1]],
vertex[triangle[i][2]],
triangle_normal[i]);
}
return last_used+1; /* size == first free */
}
void reduce_group_vertices(int g)
{
int *rtab;
int g_size;
Bool changed=False;
g_size=group_size(g,group, vertex_used);
if(g_size==0)
{
printf("current group contains 0 vertices !!!\n");
return;
}
rtab= (int*) malloc(2*g_size*sizeof(int));
{
int i,j;
j=0;
for(i=0; i<VERTEX_MAX && j<g_size; i++)
if(vertex_used[i] && group[i]==g)
{
*(rtab+2*j)=i;
*(rtab+2*j+1)=j;
j++;
}
for(i=1; i<g_size; i++)
for(j=0; j<i && *(rtab+2*i+1)== i; j++)
if(vector_distance(vertex[*(rtab+2*i)],vertex[*(rtab+2*j)])<=
reduction_epsilon)
{
changed=True;
while(*(rtab+2*j+1)!=j) j=*(rtab+2*j+1);
*(rtab+2*i+1)=j;
}
}
if(!changed)
{
printf("No vertex reductions can be done.\n");
free(rtab);
return;
}
group_statistics(g);
backup();
printf("REDUCING ...\n");
{
int i, old_top, e[3], t[4];
graph_marked_init();
for(i=0; i<g_size; i++)
graph_marked[*(rtab+2*i)]= *(rtab+2*(*(rtab+2*i+1)));
/* if graph_marked[i]!=-1 thten group[i]== g and i should be replaced */
/* by graph_marked[i] */
/* REDUCE EDGES */
old_top=edge_top;
i=0;
while(i<edge_top)
if(graph_marked[edge[i][0]]!= -1||
graph_marked[edge[i][1]]!= -1
)
{
edgecpy(e, edge[i]);
edge_delete(i);
e[0]=graph_marked[e[0]];
e[1]=graph_marked[e[1]];
edge_sort(e);
edgecpy(edge[edge_top],e);
}
else i++;
qsort(edge+edge_top, old_top-edge_top, sizeof(int[3]), edge_compare);
i=edge_top;
while(i<old_top)
{
if(i==0 || !edge_eq(edge[i-1],edge[i]))
{
edgecpy(edge[edge_top],edge[i]);
vertex_used[edge[edge_top][0]]++;
vertex_used[edge[edge_top][1]]++;
edge_top++;
}
i++;
}
/* REDUCE TRIANGLES */
old_top=triangle_top;
i=0;
while(i<triangle_top)
if(graph_marked[triangle[i][0]]!= -1||
graph_marked[triangle[i][1]]!= -1||
graph_marked[triangle[i][2]]!= -1
)
{
trianglecpy(t, triangle[i]);
triangle_delete(i);
t[0]=graph_marked[t[0]];
t[1]=graph_marked[t[1]];
t[2]=graph_marked[t[2]];
triangle_sort(t);
trianglecpy(triangle[triangle_top],t);
}
else i++;
qsort(triangle+triangle_top, old_top-triangle_top, sizeof(int[4]),
triangle_compare);
i=triangle_top;
while(i<old_top)
{
if(i==0 || !triangle_eq(triangle[i-1],triangle[i]))
{
trianglecpy(triangle[triangle_top],triangle[i]);
vertex_used[triangle[triangle_top][0]]++;
vertex_used[triangle[triangle_top][1]]++;
vertex_used[triangle[triangle_top][2]]++;
triangle_top++;
}
i++;
}
/* DOKONCZ ... dla triangles */
}
free(rtab);
group_statistics(g);
}
void polygon_add(Bool edges, Bool triangles)
{
int first_free;
int group_new;
int i;
first_free=vertex_compress(vertex,
vertex_used,
edge_top, edge,
triangle_top, triangle, triangle_normal,
group);
if(first_free+polygon_n >= VERTEX_MAX)
{
printf("polygon_add: too many vertices !!!\n");
return;
}
if(edges && edge_top+polygon_n >= EDGE_MAX)
{
printf("polygon_add: too many edges !!!\n");
return;
}
if(triangles && triangle_top+polygon_n-2 >= TRIANGLE_MAX)
{
printf("polygon_add: too many triangles !!!\n");
return;
}
group_new=group_max(group,vertex_used)+1;
group_change_current(group_new, &group_current, group, vertex_used );
for(i=0; i<polygon_n; i++)
polygon_get_vertex(i,vertex[i+first_free]);
if(edges)
{
for(i=0; i<polygon_n; i++)
{
edge[edge_top+i][0]=first_free+i;
edge[edge_top+i][1]=first_free+(i+1)%polygon_n;
edge_sort(edge[edge_top+i]);
edge[edge_top+i][2]=current_color;
vertex_used[first_free+i]++;
vertex_used[first_free+(i+1)%polygon_n]++;
}
edge_top+=polygon_n;
}
if(triangles)
{
for(i=0; i<polygon_n-2; i++)
{
triangle[triangle_top+i][0]=first_free;
triangle[triangle_top+i][1]=first_free+i+1;
triangle[triangle_top+i][2]=first_free+i+2;
triangle[triangle_top+i][3]=current_color;
/* triangle_sort(triangle[triangle_top+i]); */
triangle_set_normal(triangle_top+i);
vertex_used[first_free]++;
vertex_used[first_free+i+1]++;
vertex_used[first_free+i+2]++;
}
triangle_top+=polygon_n-2;
}
group_change_current(group_current, &group_current, group, vertex_used );
}
