/********************************************************************/
/* STRIPE: converting a polygonal model to triangle strips
Francine Evans, 1996.
SUNY @ Stony Brook
Advisors: Steven Skiena and Amitabh Varshney
*/
/********************************************************************/
/*---------------------------------------------------------------------*/
/* STRIPE: common.c
This file contains common code used in both the local and global algorithm
*/
/*---------------------------------------------------------------------*/
#include <stdlib.h>
#include "polverts.h"
#include "extend.h"
#include "output.h"
#include "triangulate.h"
#include "util.h"
#include "add.h"
int Old_Adj(int face_id)
{
/* Find the bucket that the face_id is currently in,
because maybe we will be deleting it.
*/
PF_FACES temp = NULL;
ListHead *pListHead;
int size,y;
pListHead = PolFaces[face_id];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
if ( temp == NULL )
{
printf("The face was already deleted, there is an error\n");
exit(0);
}
size = temp->nPolSize;
if (Done(face_id,size,&y) == NULL)
{
printf("There is an error in finding the face\n");
exit(0);
}
return y;
}
int Number_Adj(int id1, int id2, int curr_id)
{
/* Given edge whose endpoints are specified by id1 and id2,
determine how many polygons share this edge and return that
number minus one (since we do not want to include the polygon
that the caller has already).
*/
int size,y,count=0;
PF_EDGES temp = NULL;
PF_FACES temp2 = NULL;
ListHead *pListHead;
BOOL there= FALSE;
/* Always want smaller id first */
switch_lower(&id1,&id2);
pListHead = PolEdges[id1];
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
if (temp == NULL)
/* new edge that was created might not be here */
return 0;
while (temp->edge[0] != id2)
{
count++;
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
if (temp == NULL)
/* This edge was not there in the original, which
mean that we created it in the partial triangulation.
So it is adjacent to nothing.
*/
return 0;
}
/* Was not adjacent to anything else except itself */
if (temp->edge[2] == -1)
return 0;
else
{
/* It was adjacent to another polygon, but maybe we did this
polygon already, and it was done partially so that this edge
could have been done
*/
if (curr_id != temp->edge[1])
{
/* Did we use this polygon already?and it was deleted
completely from the structure
*/
pListHead = PolFaces[temp->edge[1]];
temp2 = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
if (Done(temp->edge[1],temp2->nPolSize,&size) == NULL)
return 0;
}
else
{
pListHead = PolFaces[temp->edge[2]];
temp2 = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
if (Done(temp->edge[2],temp2->nPolSize,&size)== NULL)
return 0;
}
/* Now we have to check whether it was partially done, before
we can say definitely if it is adjacent.
Check each edge of the face and tally the number of adjacent
polygons to this face.
*/
if ( temp2 != NULL )
{
/* Size of the polygon */
size = temp2->nPolSize;
for (y = 0; y< size; y++)
{
/* If we are doing partial triangulation, we must check
to see whether the edge is still there in the polygon,
since we might have done a portion of the polygon
and saved the rest for later.
*/
if (y != (size-1))
{
if( ((id1 == *(temp2->pPolygon+y)) && (id2 ==*(temp2->pPolygon+y+1)))
|| ((id2 == *(temp2->pPolygon+y)) && (id1 ==*(temp2->pPolygon+y+1))))
/* edge is still there we are ok */
there = TRUE;
}
else
{
if( ((id1 == *(temp2->pPolygon)) && (id2 == *(temp2->pPolygon+size-1)))
|| ((id2 == *(temp2->pPolygon)) && (id1 ==*(temp2->pPolygon+size-1))))
/* edge is still there we are ok */
there = TRUE;
}
}
}
if (there )
return 1;
return 0;
}
}
int Min_Adj(int id)
{
/* Used for the lookahead to break ties. It will
return the minimum adjacency found at this face.
*/
int y,numverts,t,x=60;
PF_FACES temp=NULL;
ListHead *pListHead;
/* If polygon was used then we can't use this face */
if (Done(id,59,&y) == NULL)
return 60;
/* It was not used already */
pListHead = PolFaces[id];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
if ( temp != NULL )
{
numverts = temp->nPolSize;
for (y = 0; y< numverts; y++)
{
if (y != (numverts-1))
t = Number_Adj(*(temp->pPolygon+y),*(temp->pPolygon+y+1),id);
else
t = Number_Adj(*(temp->pPolygon),*(temp->pPolygon+(numverts-1)),id);
if (t < x)
x = t;
}
}
if (x == -1)
{
printf("Error in the look\n");
exit(0);
}
return x;
}
void Edge_Least(int *index,int *new1,int *new2,int face_id,int size)
{
/* We had a polygon without an input edge and now we re going to pick one
of the edges with the least number of adjacencies to be the input
edge
*/
register int x,value,smallest=60;
for (x = 0; x<size; x++)
{
if (x != (size -1) )
value = Number_Adj(*(index+x),*(index+x+1),face_id);
else
value = Number_Adj(*(index),*(index+size-1),face_id);
if (value < smallest)
{
smallest = value;
if (x != (size -1))
{
*new1 = *(index+x);
*new2 = *(index+x+1);
}
else
{
*new1 = *(index);
*new2 = *(index+size-1);
}
}
}
if ((smallest == 60) || (smallest < 0))
{
printf("There is an error in getting the least edge\n");
exit(0);
}
}
void Check_In_Polygon(int face_id, int *min, int size)
{
/* Check to see the adjacencies by going into a polygon that has
greater than 4 sides.
*/
ListHead *pListHead;
PF_FACES temp;
int y,id1,id2,id3,x=0,z=0;
int saved[2];
int big_saved[60];
pListHead = PolFaces[face_id];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
/* Get the input edge that we came in on */
Last_Edge(&id1,&id2,&id3,0);
/* Find the number of adjacencies to the edges that are adjacent
to the input edge.
*/
for (y=0; y< size; y++)
{
if (y != (size-1))
{
if (((*(temp->pPolygon+y) == id2) && (*(temp->pPolygon+y+1) != id3))
|| ((*(temp->pPolygon+y) == id3) && (*(temp->pPolygon+y+1) != id2)))
{
saved[x++] = Number_Adj(*(temp->pPolygon+y),*(temp->pPolygon+y+1),face_id);
big_saved[z++] = saved[x-1];
}
else
big_saved[z++] = Number_Adj(*(temp->pPolygon+y),*(temp->pPolygon+y+1),face_id);
}
else
{
if (((*(temp->pPolygon) == id2) && (*(temp->pPolygon+size-1) != id3))
|| ((*(temp->pPolygon) == id3) && (*(temp->pPolygon+size-1) != id2)))
{
saved[x++] = Number_Adj(*(temp->pPolygon),*(temp->pPolygon+size-1),face_id);
big_saved[z++] = saved[x-1];
}
else
big_saved[z++] = Number_Adj(*(temp->pPolygon),*(temp->pPolygon+size-1),face_id);
}
}
/* There was an input edge */
if (x == 2)
{
if (saved[0] < saved[1])
/* Count the polygon that we will be cutting as another adjacency*/
*min = saved[0] + 1;
else
*min = saved[1] + 1;
}
/* There was not an input edge */
else
{
if (z != size)
{
printf("There is an error with the z %d %d\n",size,z);
exit(0);
}
*min = 60;
for (x = 0; x < size; x++)
{
if (*min > big_saved[x])
*min = big_saved[x];
}
}
}
void New_Face (int face_id, int v1, int v2, int v3)
{
/* We want to change the face that was face_id, we will
change it to a triangle, since the rest of the polygon
was already outputtted
*/
ListHead *pListHead;
PF_FACES temp = NULL;
pListHead = PolFaces[face_id];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0);
/* Check each edge of the face and tally the number of adjacent
polygons to this face.
*/
if ( temp != NULL )
{
/* Size of the polygon */
if (temp->nPolSize != 4)
{
printf("There is a miscalculation in the partial\n");
exit (0);
}
temp->nPolSize = 3;
*(temp->pPolygon) = v1;
*(temp->pPolygon+1) = v2;
*(temp->pPolygon+2) = v3;
}
}
void New_Size_Face (int face_id)
{
/* We want to change the face that was face_id, we will
change it to a triangle, since the rest of the polygon
was already outputtted
*/
ListHead *pListHead;
PF_FACES temp = NULL;
pListHead = PolFaces[face_id];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
/* Check each edge of the face and tally the number of adjacent
polygons to this face.
*/
if ( temp != NULL )
(temp->nPolSize)--;
else
printf("There is an error in updating the size\n");
}
void Check_In_Quad(int face_id,int *min)
{
/* Check to see what the adjacencies are for the polygons that
are inside the quad, ie the 2 triangles that we can form.
*/
ListHead *pListHead;
int y,id1,id2,id3,x=0;
int saved[4];
PF_FACES temp;
register int size = 4;
pListHead = PolFaces[face_id];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
/* Get the input edge that we came in on */
Last_Edge(&id1,&id2,&id3,0);
/* Now find the adjacencies for the inside triangles */
for (y = 0; y< size; y++)
{
/* Will not do this if the edge is the input edge */
if (y != (size-1))
{
if ((((*(temp->pPolygon+y) == id2) && (*(temp->pPolygon+y+1) == id3))) ||
(((*(temp->pPolygon+y) == id3) && (*(temp->pPolygon+y+1) == id2))))
saved[x++] = -1;
else
{
if (x == 4)
{
printf("There is an error in the check in quad \n");
exit(0);
}
/* Save the number of Adjacent Polygons to this edge */
saved[x++] = Number_Adj(*(temp->pPolygon+y),*(temp->pPolygon+y+1),face_id);
}
}
else if ((((*(temp->pPolygon) == id2) && (*(temp->pPolygon+size-1) == id3))) ||
(((*(temp->pPolygon) == id3) && (*(temp->pPolygon+size-1) == id2))) )
saved[x++] = -1;
else
{
if (x == 4)
{
printf("There is an error in the check in quad \n");
exit(0);
}
/* Save the number of Adjacent Polygons to this edge */
saved[x++] = Number_Adj(*(temp->pPolygon),*(temp->pPolygon+size-1),face_id);
}
}
if (x != 4)
{
printf("Did not enter all the values %d \n",x);
exit(0);
}
*min = 10;
for (x=0; x<4; x++)
{
if (x!= 3)
{
if ((saved[x] != -1) && (saved[x+1] != -1) &&
((saved[x] + saved[x+1]) < *min))
*min = saved[x] + saved[x+1];
}
else
{
if ((saved[0] != -1) && (saved[x] != -1) &&
((saved[x] + saved[0]) < *min))
*min = saved[0] + saved[x];
}
}
}
int Get_Output_Edge(int face_id, int size, int *index,int id2,int id3)
{
/* Return the vertex adjacent to either input1 or input2 that
is adjacent to the least number of polygons on the edge that
is shared with either input1 or input2.
*/
register int x=0,y;
int saved[2];
int edges[2][1];
for (y = 0; y < size; y++)
{
if (y != (size-1))
{
if (((*(index+y) == id2) && (*(index+y+1) != id3))
|| ((*(index+y) == id3) && (*(index+y+1) != id2)))
{
saved[x++] = Number_Adj(*(index+y),*(index+y+1),face_id);
edges[x-1][0] = *(index+y+1);
}
else if (y != 0)
{
if (( (*(index+y) == id2) && (*(index+y-1) != id3) ) ||
( (*(index+y) == id3) && (*(index+y-1) != id2)) )
{
saved[x++] = Number_Adj(*(index+y),*(index+y-1),face_id);
edges[x-1][0] = *(index+y-1);
}
}
else if (y == 0)
{
if (( (*(index) == id2) && (*(index+size-1) != id3) ) ||
( (*(index) == id3) && (*(index+size-1) != id2)) )
{
saved[x++] = Number_Adj(*(index),*(index+size-1),face_id);
edges[x-1][0] = *(index+size-1);
}
}
}
else
{
if (((*(index+size-1) == id2) && (*(index) != id3))
|| ((*(index+size-1) == id3) && (*(index) != id2)))
{
saved[x++] = Number_Adj(*(index),*(index+size-1),face_id);
edges[x-1][0] = *(index);
}
if (( (*(index+size-1) == id2) && (*(index+y-1) != id3) ) ||
( (*(index+size-1) == id3) && (*(index+y-1) != id2)) )
{
saved[x++] = Number_Adj(*(index+size-1),*(index+y-1),face_id);
edges[x-1][0] = *(index+y-1);
}
}
}
if ((x != 2))
{
printf("There is an error in getting the input edge %d \n",x);
exit(0);
}
if (saved[0] < saved[1])
return edges[0][0];
else
return edges[1][0];
}
void Get_Input_Edge(int *index,int id1,int id2,int id3,int *new1,int *new2,int size,
int face_id)
{
/* We had a polygon without an input edge and now we are going to pick one
as the input edge. The last triangle was id1,id2,id3, we will try to
get an edge to have something in common with one of those vertices, otherwise
we will pick the edge with the least number of adjacencies.
*/
register int x;
int saved[3];
saved[0] = -1;
saved[1] = -1;
saved[2] = -1;
/* Go through the edges to see if there is one in common with one
of the vertices of the last triangle that we had, preferably id2 or
id3 since those are the last 2 things in the stack of size 2.
*/
for (x=0; x< size; x++)
{
if (*(index+x) == id1)
{
if (x != (size-1))
saved[0] = *(index+x+1);
else
saved[0] = *(index);
}
if (*(index+x) == id2)
{
if (x != (size-1))
saved[1] = *(index+x+1);
else
saved[1] = *(index);
}
if (*(index+x) == id3)
{
if (x != (size -1))
saved[2] = *(index+x+1);
else
saved[2] = *(index);
}
}
/* Now see what we saved */
if (saved[2] != -1)
{
*new1 = id3;
*new2 = saved[2];
return;
}
else if (saved[1] != -1)
{
*new1 = id2;
*new2 = saved[1];
return;
}
else if (saved[0] != -1)
{
*new1 = id1;
*new2 = saved[0];
return;
}
/* We did not find anything so get the edge with the least number of adjacencies */
Edge_Least(index,new1,new2,face_id,size);
}
int Find_Face(int current_face, int id1, int id2, int *bucket)
{
/* Find the face that is adjacent to the edge and is not the
current face.
*/
register int size,each_poly=0,y,tally=0,count=0;
PF_EDGES temp = NULL;
PF_FACES temp2 = NULL;
ListHead *pListHead;
int next_face;
BOOL there = FALSE;
/* Always want smaller id first */
switch_lower(&id1,&id2);
pListHead = PolEdges[id1];
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
/* The input edge was a new edge */
if (temp == NULL)
return -1;
while (temp->edge[0] != id2)
{
count++;
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
/* The input edge was a new edge */
if (temp == NULL)
return -1;
}
/* Was not adjacent to anything else except itself */
if (temp->edge[2] == -1)
return -1;
else
{
if (temp->edge[2] == current_face)
next_face = temp->edge[1];
else
next_face = temp->edge[2];
}
/* We have the other face adjacent to this edge, it is
next_face.
*/
pListHead = PolFaces[next_face];
temp2 = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
/* See if the face was already deleted, and where
it is if it was not
*/
if (Done(next_face,59,bucket) == NULL)
return -1;
/* Make sure the edge is still in this polygon, and that it is not
done
*/
/* Size of the polygon */
size = temp2->nPolSize;
for (y = 0; y< size; y++)
{
/* Make sure that the edge is still in the
polygon and was not deleted, because if the edge was
deleted, then we used it already.
*/
if (y != (size-1))
{
if( ((id1 == *(temp2->pPolygon+y)) && (id2 ==*(temp2->pPolygon+y+1)))
|| ((id2 == *(temp2->pPolygon+y)) && (id1 ==*(temp2->pPolygon+y+1))))
/* edge is still there we are ok */
there = TRUE;
}
else
{
if( ((id1 == *(temp2->pPolygon)) && (id2 ==*(temp2->pPolygon+size-1)))
|| ((id2 == *(temp2->pPolygon)) && (id1 ==*(temp2->pPolygon+size-1))))
/* edge is still there we are ok */
there = TRUE;
}
}
if (!there)
/* Edge already used and deleted from the polygon*/
return -1;
else
return next_face;
}
BOOL Look_Up(int id1,int id2,int face_id)
{
/* See if the endpoints of the edge specified by id1 and id2
are adjacent to the face with face_id
*/
register int count = 0;
PF_EDGES temp = NULL;
ListHead *pListHead;
PF_FACES temp2 = NULL;
/* Always want smaller id first */
switch_lower(&id1,&id2);
pListHead = PolEdges[id1];
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
if (temp == NULL)
/* Was a new edge that we created */
return 0;
while (temp->edge[0] != id2)
{
count++;
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
if (temp == NULL)
/* Was a new edge that we created */
return 0;
}
/* Was not adjacent to anything else except itself */
if ((temp->edge[2] == face_id) || (temp->edge[1] == face_id))
{
/* Edge was adjacent to face, make sure that edge is
still there
*/
if (Exist(face_id,id1,id2))
return 1;
else
return 0;
}
else
return 0;
}
void Add_Id_Strips(int id, int where)
{
/* Just save the triangle for later */
P_STRIPS pfNode;
pfNode = (P_STRIPS) malloc(sizeof(Strips) );
if ( pfNode )
{
pfNode->face_id = id;
if (where == 1)
AddTail(strips[0],(PLISTINFO) pfNode);
/* We are backtracking in the strip */
else
AddHead(strips[0],(PLISTINFO) pfNode);
}
else
{
printf("There is not enough memory to allocate for the strips\n");
exit(0);
}
}
int Num_Adj(int id1, int id2)
{
/* Given edge whose endpoints are specified by id1 and id2,
determine how many polygons share this edge and return that
number minus one (since we do not want to include the polygon
that the caller has already).
*/
PF_EDGES temp = NULL;
ListHead *pListHead;
register count=-1;
/* Always want smaller id first */
switch_lower(&id1,&id2);
pListHead = PolEdges[id1];
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
if (temp == NULL)
{
printf("There is an error in the creation of the table \n");
exit(0);
}
while (temp->edge[0] != id2)
{
count++;
temp = (PF_EDGES) PeekList(pListHead,LISTHEAD,count);
if (temp == NULL)
{
printf("There is an error in the creation of the table\n");
exit(0);
}
}
/* Was not adjacent to anything else except itself */
if (temp->edge[2] == -1)
return 0;
return 1;
}
void Add_Sgi_Adj(int bucket,int face_id)
{
/* This routine will add the face to the proper bucket,
depending on how many faces are adjacent to it (what the
value bucket should be).
*/
P_ADJACENCIES pfNode;
pfNode = (P_ADJACENCIES) malloc(sizeof(ADJACENCIES) );
if ( pfNode )
{
pfNode->face_id = face_id;
AddHead(array[bucket],(PLISTINFO) pfNode);
}
else
{
printf("Out of memory for the SGI adj list!\n");
exit(0);
}
}
void Find_Adjacencies(int num_faces)
{
register int x,y;
register int numverts;
PF_FACES temp=NULL;
ListHead *pListHead;
/* Fill in the adjacencies data structure for all the faces */
for (x=0;x<num_faces;x++)
{
pListHead = PolFaces[x];
temp = ( PF_FACES ) PeekList( pListHead, LISTHEAD, 0 );
if ( temp != NULL )
{
numverts = temp->nPolSize;
if (numverts != 1)
{
for (y = 0; y< numverts; y++)
{
if (y != (numverts-1))
Add_AdjEdge(*(temp->pPolygon+y),*(temp->pPolygon+y+1),x,y);
else
Add_AdjEdge(*(temp->pPolygon),*(temp->pPolygon+(numverts-1)),x,numverts-1);
}
}
temp = NULL;
}
}
}