665 lines
23 KiB
C
665 lines
23 KiB
C
/********************************************************************/
|
|
/* STRIPE: converting a polygonal model to triangle strips
|
|
Francine Evans, 1996.
|
|
SUNY @ Stony Brook
|
|
Advisors: Steven Skiena and Amitabh Varshney
|
|
*/
|
|
/********************************************************************/
|
|
|
|
/*---------------------------------------------------------------------*/
|
|
/* STRIPE: partial.c
|
|
This file contains routines that are used partial triangulation of polygons
|
|
*/
|
|
/*---------------------------------------------------------------------*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "global.h"
|
|
#include "outputex.h"
|
|
#include "polvertsex.h"
|
|
#include "triangulatex.h"
|
|
#include "sturctsex.h"
|
|
#include "polverts.h"
|
|
#include "common.h"
|
|
#include "util.h"
|
|
|
|
void P_Triangulate_Quad(int out_edge1,int out_edge2,int in_edge1,
|
|
int in_edge2,int size,int *index,
|
|
FILE *output,FILE *fp,int reversed,int face_id,
|
|
int *next_id,ListHead *pListHead,
|
|
P_ADJACENCIES temp,
|
|
int where)
|
|
{
|
|
int vertex4,vertex5,dummy=60;
|
|
|
|
/* This routine will nonblindly triangulate a quad, meaning
|
|
that there is a definite input and a definite output
|
|
edge that we must adhere to. Reversed will tell the orientation
|
|
of the input edge. (Reversed is -1 is we do not have an input
|
|
edge, in other words we are at the beginning of a strip.)
|
|
Out_edge* is the output edge, and in_edge* is the input edge.
|
|
Index are the edges of the polygon
|
|
and size is the size of the polygon. Begin is whether we are
|
|
at the start of a new strip.
|
|
Note that we will not necessarily triangulate the whole quad;
|
|
maybe we will do half and leave the other half (a triangle)
|
|
for later.
|
|
*/
|
|
|
|
|
|
/* If we do not have an input edge, then we can make our input
|
|
edge whatever we like, therefore it will be easier to come
|
|
out on the output edge. In this case the whole quad is done.
|
|
*/
|
|
if (reversed == -1)
|
|
{
|
|
vertex4 = AdjacentEx(out_edge1,out_edge2,index,size);
|
|
vertex5 = Get_Other_Vertex(vertex4,out_edge1,out_edge2,index);
|
|
Output_TriEx(vertex5,vertex4,out_edge1,output,-1,-1,where);
|
|
Output_TriEx(vertex4,out_edge1,out_edge2,output,-1,-1,where);
|
|
dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy);
|
|
RemoveList(pListHead,(PLISTINFO) temp);
|
|
return;
|
|
}
|
|
|
|
/* These are the 5 cases that we can have for the output edge */
|
|
|
|
/* Are they consecutive so that we form a triangle to
|
|
peel off, but cannot use the whole quad?
|
|
*/
|
|
|
|
if (in_edge2 == out_edge1)
|
|
{
|
|
/* Output the triangle that comes out the correct
|
|
edge. Save the other half for later.
|
|
*/
|
|
vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge2,index);
|
|
Output_TriEx(in_edge1,in_edge2,out_edge2,output,-1,-1,where);
|
|
/* Now we have a triangle used, and a triangle that is
|
|
left for later.
|
|
*/
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,in_edge2,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
/* Put the new face in the proper bucket of adjacencies
|
|
There are 2 edges that need to be checked for the triangle
|
|
that was just outputted. For the output edge we definitely
|
|
will be decreasing the adjacency, but we must check for the
|
|
input edge.
|
|
*/
|
|
|
|
dummy = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp,FALSE);
|
|
dummy = Change_FaceEx(face_id,in_edge2,out_edge2,pListHead,temp,TRUE);
|
|
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the triangle as the new face
|
|
*/
|
|
New_Face(face_id,in_edge1,out_edge2,vertex4);
|
|
return;
|
|
}
|
|
else if (in_edge1 == out_edge1)
|
|
{
|
|
/* We want to output the first triangle (whose output
|
|
edge is not the one that we want.
|
|
We have to find the vertex that we need, which is
|
|
the other vertex which we do not have.
|
|
*/
|
|
vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge2,index);
|
|
Output_TriEx(in_edge2,in_edge1,out_edge2,output,-1,-1,where);
|
|
/* Now we have a triangle used, and a triangle that is
|
|
left for later.
|
|
*/
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,out_edge1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
dummy = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp,FALSE);
|
|
dummy = Change_FaceEx(face_id,in_edge1,out_edge2,pListHead,temp,TRUE);
|
|
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the triangle as the new face
|
|
*/
|
|
New_Face(face_id,in_edge2,out_edge2,vertex4);
|
|
return;
|
|
}
|
|
|
|
/* Consecutive cases again, but with the output edge reversed */
|
|
else if (in_edge1 == out_edge2)
|
|
{
|
|
vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge1,index);
|
|
Output_TriEx(in_edge2,in_edge1,out_edge1,output,-1,-1,where);
|
|
/* Now we have a triangle used, and a triangle that is
|
|
left for later.
|
|
*/
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,out_edge1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
dummy = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp,FALSE);
|
|
dummy = Change_FaceEx(face_id,out_edge1,out_edge2,pListHead,temp,TRUE);
|
|
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the triangle as the new face
|
|
*/
|
|
New_Face(face_id,in_edge2,out_edge1,vertex4);
|
|
return;
|
|
}
|
|
else if (in_edge2 == out_edge2)
|
|
{
|
|
vertex4 = Get_Other_Vertex(in_edge1,in_edge2,out_edge1,index);
|
|
Output_TriEx(in_edge1,in_edge2,out_edge1,output,-1,-1,where);
|
|
/* Now we have a triangle used, and a triangle that is
|
|
left for later.
|
|
*/
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,out_edge1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
dummy = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp,FALSE);
|
|
dummy = Change_FaceEx(face_id,out_edge1,out_edge2,pListHead,temp,TRUE);
|
|
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the triangle as the new face
|
|
*/
|
|
New_Face(face_id,in_edge1,out_edge1,vertex4);
|
|
return;
|
|
}
|
|
|
|
/* The final case is where we want to come out the opposite
|
|
edge.
|
|
*/
|
|
else
|
|
{
|
|
if( ((!reversed) && (out_edge1 == (AdjacentEx(in_edge1,in_edge2,index,size)))) ||
|
|
((reversed) && (out_edge2 == (AdjacentEx(in_edge2,in_edge1,index,size)))))
|
|
{
|
|
/* We need to know the orientation of the input
|
|
edge, so we know which way to put the diagonal.
|
|
And also the output edge, so that we triangulate
|
|
correctly. Does not need partial.
|
|
*/
|
|
Output_TriEx(in_edge1,in_edge2,out_edge2,output,-1,-1,where);
|
|
Output_TriEx(in_edge2,out_edge2,out_edge1,output,-1,-1,where);
|
|
dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy);
|
|
RemoveList(pListHead,(PLISTINFO) temp);
|
|
}
|
|
else
|
|
{
|
|
/* Input and output orientation was reversed, so diagonal will
|
|
be reversed from above.
|
|
*/
|
|
Output_TriEx(in_edge1,in_edge2,out_edge1,output,-1,-1,where);
|
|
Output_TriEx(in_edge2,out_edge1,out_edge2,output,-1,-1,where);
|
|
dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy);
|
|
RemoveList(pListHead,(PLISTINFO) temp);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void P_Triangulate_Polygon(int out_edge1,int out_edge2,int in_edge1,
|
|
int in_edge2,int size,
|
|
int *index,FILE *output,FILE *fp,
|
|
int reversed,int face_id,int *next_id,
|
|
ListHead *pListHead, P_ADJACENCIES temp2,
|
|
int where)
|
|
{
|
|
/* We have a polygon greater than 4 sides, which we wish
|
|
to partially triangulate
|
|
*/
|
|
int next_bucket,vertex4,dummy = 60;
|
|
int *temp;
|
|
P_ADJACENCIES pfNode;
|
|
|
|
|
|
/* Since we are calling this recursively, we have to check whether
|
|
we are down to the case of the quad.
|
|
*/
|
|
if (size == 4)
|
|
{
|
|
P_Triangulate_Quad(out_edge1,out_edge2,in_edge1,in_edge2,size,
|
|
index,output,fp,reversed,face_id,next_id,
|
|
pListHead,temp2,where);
|
|
return;
|
|
}
|
|
|
|
/* We do not have a specified input edge, and therefore we
|
|
can make it anything we like, as long as we still come out
|
|
the output edge that we want.
|
|
*/
|
|
if (reversed == -1)
|
|
{
|
|
/* Get the vertex for the last triangle, which is
|
|
the one coming out the output edge, before we do
|
|
any deletions to the list. We will be doing this
|
|
bottom up.
|
|
*/
|
|
vertex4 = AdjacentEx(out_edge1,out_edge2,index,size);
|
|
temp = (int *) malloc(sizeof(int) * size);
|
|
memcpy(temp,index,sizeof(int)*size);
|
|
Delete_From_ListEx(out_edge2,index,size);
|
|
/* We do not have to partially triangulate, since
|
|
we will do the whole thing, so use the whole routine
|
|
*/
|
|
Triangulate_PolygonEx(vertex4,out_edge1,in_edge2,
|
|
vertex4,size-1,index,output,fp,reversed,face_id,
|
|
next_id,pListHead,temp2,where);
|
|
memcpy(index,temp,sizeof(int)*size);
|
|
/* Lastly do the triangle that comes out the output
|
|
edge.
|
|
*/
|
|
Output_TriEx(vertex4,out_edge1,out_edge2,output,-1,-1,where);
|
|
/* We were able to do the whole polygon, now we
|
|
can delete the whole thing from our data structure.
|
|
*/
|
|
dummy = Update_AdjacenciesEx(face_id, &dummy, &dummy,&dummy,&dummy);
|
|
RemoveList(pListHead,(PLISTINFO) temp2);
|
|
return;
|
|
}
|
|
|
|
/* These are the 5 cases that we can have for the output edge */
|
|
|
|
/* Are they consecutive so that we form a triangle to
|
|
peel off that comes out the correct output edge,
|
|
but we cannot use the whole polygon?
|
|
*/
|
|
if (in_edge2 == out_edge1)
|
|
{
|
|
Output_TriEx(in_edge1,out_edge1,out_edge2,output,-1,-1,where);
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,out_edge1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,out_edge1,out_edge2,pListHead,temp2,TRUE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge2,index,size);
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
return;
|
|
}
|
|
|
|
/* Next case is where it is again consecutive, but the triangle
|
|
formed by the consecutive edges do not come out of the
|
|
correct output edge. (the input edge will be reversed in
|
|
the next triangle)
|
|
*/
|
|
else if (in_edge1 == out_edge1)
|
|
{
|
|
/* Get vertex adjacent to in_edge2, but is not in_edge1 */
|
|
Output_TriEx(in_edge2,in_edge1,out_edge2,output,-1,-1,where);
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,out_edge1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,out_edge1,out_edge2,pListHead,temp2,TRUE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge1,index,size);
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
return;
|
|
}
|
|
|
|
/* Consecutive cases again, but with the output edge reversed */
|
|
else if (in_edge1 == out_edge2)
|
|
{
|
|
Output_TriEx(in_edge2,in_edge1,out_edge1,output,-1,-1,where);
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge1,out_edge2,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,out_edge1,out_edge2,pListHead,temp2,TRUE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge1,index,size);
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
return;
|
|
}
|
|
else if (in_edge2 == out_edge2)
|
|
{
|
|
Output_TriEx(in_edge1,in_edge2,out_edge1,output,-1,-1,where);
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(out_edge2,out_edge1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,out_edge1,out_edge2,pListHead,temp2,TRUE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge2,index,size);
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
return;
|
|
}
|
|
|
|
/* Else the edge is not consecutive, and it is sufficiently
|
|
far away, for us not to make a conclusion at this time.
|
|
So we can take off a triangle and recursively call this
|
|
function.
|
|
*/
|
|
else
|
|
{
|
|
if (!reversed)
|
|
{
|
|
vertex4 = AdjacentEx(in_edge2,in_edge1,index,size);
|
|
Output_TriEx(in_edge1,in_edge2,vertex4,output,-1,-1,where);
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(in_edge1,vertex4,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,vertex4,pListHead,temp2,FALSE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge1,index,size);
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
|
|
/* Save the info for the new bucket, we will need it on
|
|
the next pass for the variables, pListHead and temp
|
|
*/
|
|
pListHead = array[next_bucket];
|
|
pfNode = (P_ADJACENCIES) malloc(sizeof(ADJACENCIES) );
|
|
if ( pfNode )
|
|
pfNode->face_id = face_id;
|
|
temp2 = (P_ADJACENCIES) (SearchList(array[next_bucket], pfNode,
|
|
(int (*)(void *,void *)) (Compare)));
|
|
if (temp2 == NULL)
|
|
{
|
|
printf("There is an error finding the next polygon10\n",next_bucket,face_id);
|
|
exit(0);
|
|
}
|
|
|
|
P_Triangulate_Polygon(out_edge1,out_edge2,in_edge2,
|
|
vertex4,size-1,index,output,fp,!reversed,
|
|
face_id,next_id,pListHead,temp2,where);
|
|
}
|
|
else
|
|
{
|
|
vertex4 = AdjacentEx(in_edge1,in_edge2,index,size);
|
|
Output_TriEx(in_edge2,in_edge1,vertex4,output,-1,-1,where);
|
|
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(in_edge2,vertex4,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,in_edge2,vertex4,pListHead,temp2,FALSE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge2,index,size);
|
|
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
|
|
/* Save the info for the new bucket, we will need it on
|
|
the next pass for the variables, pListHead and temp
|
|
*/
|
|
pListHead = array[next_bucket];
|
|
pfNode = (P_ADJACENCIES) malloc(sizeof(ADJACENCIES) );
|
|
if ( pfNode )
|
|
pfNode->face_id = face_id;
|
|
temp2 = (P_ADJACENCIES) (SearchList(array[next_bucket], pfNode,
|
|
(int (*)(void *,void *)) (Compare)));
|
|
if (temp2 == NULL)
|
|
{
|
|
printf("There is an error finding the next polygon11 %d %d\n",face_id,next_bucket);
|
|
exit(0);
|
|
}
|
|
|
|
P_Triangulate_Polygon(out_edge1,out_edge2,vertex4,
|
|
in_edge1,size-1,index,output,fp,!reversed,
|
|
face_id,next_id,pListHead,temp2,where);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void P_Triangulate(int out_edge1,int out_edge2,int in_edge1,
|
|
int in_edge2,int size,int *index,
|
|
FILE *fp,FILE *output,int reversed,int face_id,
|
|
int *next_id,ListHead *pListHead,
|
|
P_ADJACENCIES temp,int where)
|
|
{
|
|
|
|
if (size == 4)
|
|
P_Triangulate_Quad(out_edge1,out_edge2,in_edge1,in_edge2,size,
|
|
index,fp,output,reversed,face_id,next_id,pListHead, temp,where);
|
|
else
|
|
P_Triangulate_Polygon(out_edge1,out_edge2,in_edge1,in_edge2,size,
|
|
index,fp,output,reversed,face_id,next_id,pListHead,temp,where);
|
|
}
|
|
|
|
void Partial_Triangulate(int size,int *index, FILE *fp,
|
|
FILE *output,int next_face_id,int face_id,
|
|
int *next_id,ListHead *pListHead,
|
|
P_ADJACENCIES temp, int where)
|
|
{
|
|
int id1,id2,id3;
|
|
int nedge1,nedge2;
|
|
int reversed;
|
|
|
|
/* We have a polygon that has to be triangulated and we cannot
|
|
do it blindly, ie we will try to come out on the edge that
|
|
has the least number of adjacencies, But also we do not
|
|
want to triangulate the whole polygon now, so that means
|
|
we will output the least number of triangles that we can
|
|
and then update the data structures, with the polygon
|
|
that is left after we are done.
|
|
*/
|
|
Last_Edge(&id1,&id2,&id3,0);
|
|
|
|
/* Find the edge that is adjacent to the new face ,
|
|
also return whether the orientation is reversed in the
|
|
face of the input edge, which is id2 and id3.
|
|
*/
|
|
reversed = Get_EdgeEx(&nedge1,&nedge2,index,next_face_id,size,id2,id3);
|
|
|
|
/* Input edge and output edge can be the same if there are more than
|
|
one polygon on an edge
|
|
*/
|
|
if ( ((nedge1 == id2) && (nedge2 == id3)) ||
|
|
((nedge1 == id3) && (nedge2 == id2)) )
|
|
/* Set output edge arbitrarily but when come out of here the
|
|
next face will be on the old output edge (identical one)
|
|
*/
|
|
nedge2 = Return_Other(index,id2,id3);
|
|
|
|
/* Do the triangulation */
|
|
P_Triangulate(nedge1,nedge2,id2,id3,size,index,fp,output,reversed,
|
|
face_id,next_id,pListHead,temp,where);
|
|
}
|
|
|
|
void Input_Edge(int face_id, int *index, int size, int in_edge1, int in_edge2,
|
|
FILE *fp, FILE *output,ListHead *pListHead, P_ADJACENCIES temp2,
|
|
int where)
|
|
{
|
|
/* The polygon had an input edge, specified by input1 and input2 */
|
|
|
|
int output1,next_bucket;
|
|
int vertex4, vertex5,dummy=60;
|
|
|
|
output1 = Get_Output_Edge(face_id,size,index,in_edge1,in_edge2);
|
|
vertex5 = AdjacentEx(in_edge2,in_edge1,index,size);
|
|
vertex4 = AdjacentEx(in_edge1,in_edge2,index,size);
|
|
|
|
if (vertex4 == output1)
|
|
{
|
|
Output_TriEx(in_edge2,in_edge1,output1,output,-1,-1,where);
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(in_edge2,output1,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,in_edge2,output1,pListHead,temp2,FALSE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge2,index,size);
|
|
|
|
}
|
|
else if (vertex5 == output1)
|
|
{
|
|
Output_TriEx(in_edge1,in_edge2,vertex5,output,-1,-1,where);
|
|
/* Now delete the adjacencies by one for all the faces
|
|
that are adjacent to the triangle that we just outputted.
|
|
*/
|
|
Delete_AdjEx(in_edge1,in_edge2,&dummy,&dummy,face_id,
|
|
&dummy,&dummy,&dummy);
|
|
Delete_AdjEx(in_edge1,vertex5,&dummy,&dummy,
|
|
face_id,&dummy,&dummy,&dummy);
|
|
/* Put the new face in the proper bucket of adjacencies */
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,in_edge2,pListHead,temp2,FALSE);
|
|
next_bucket = Change_FaceEx(face_id,in_edge1,vertex5,pListHead,temp2,FALSE);
|
|
|
|
/* Create a new edgelist without the triangle that
|
|
was just outputted.
|
|
*/
|
|
Delete_From_ListEx(in_edge1,index,size);
|
|
}
|
|
|
|
/* Update the face data structure, by deleting the old
|
|
face and putting in the polygon minus the triangle
|
|
as the new face, here we will be decrementing the size
|
|
by one.
|
|
*/
|
|
New_Size_Face(face_id);
|
|
return;
|
|
}
|
|
|
|
void Inside_Polygon(int size,int *index,FILE *fp,FILE *output,
|
|
int next_face_id,int face_id,int *next_id,
|
|
ListHead *pListHead,P_ADJACENCIES temp, int where)
|
|
{
|
|
/* We know that we have a polygon that is greater than 4 sides, and
|
|
that it is better for us to go inside the polygon for the next
|
|
one, since inside will have less adjacencies than going outside.
|
|
So, we are not doing partial for a part of the polygon.
|
|
*/
|
|
int id1,id2,id3;
|
|
int new1,new2;
|
|
|
|
Last_Edge(&id1,&id2,&id3,0);
|
|
|
|
/* See if the input edge existed in the polygon, that will help us */
|
|
if (Exist(face_id,id2,id3))
|
|
Input_Edge(face_id,index,size,id2,id3,output,fp,pListHead,temp,where);
|
|
else
|
|
{
|
|
/* Make one of the input edges
|
|
We will choose it by trying to get an edge that has something
|
|
in common with the last triangle, or by getting the edge that
|
|
is adjacent to the least number of thigs, with preference given
|
|
to the first option
|
|
*/
|
|
|
|
Get_Input_Edge(index,id1,id2,id3,&new1,&new2,size,face_id);
|
|
Input_Edge(face_id,index,size,new1,new2,output,fp,pListHead,temp,where);
|
|
}
|
|
}
|
|
|
|
|