int _PopAndUnmarkVerticesAndEdges(graphP theGraph, int Z, int stackBottom)
{
int V, e;
// Pop vertex/edge pairs until all have been popped from the stack,
// and all that's left is what was under the pairs, or until...
while (sp_GetCurrentSize(theGraph->theStack) > stackBottom)
{
sp_Pop(theGraph->theStack, V);
// If we pop the terminating vertex Z, then put it back and break
if (V == Z)
{
sp_Push(theGraph->theStack, V);
break;
}
// Otherwise, pop the edge part of the vertex/edge pair
sp_Pop(theGraph->theStack, e);
// Now unmark the vertex and edge (i.e. revert to "unvisited")
theGraph->G[V].visited = 0;
theGraph->G[e].visited = 0;
theGraph->G[gp_GetTwinArc(theGraph, e)].visited = 0;
}
return OK;
}
int _ComputeVertexPositionsInComponent(DrawPlanarContext *context, int root, int *pIndex)
{
graphP theEmbedding = context->theGraph;
listCollectionP theOrder = LCNew(theEmbedding->N);
int W, P, C, V, J;
if (theOrder == NULL)
return NOTOK;
// Determine the vertex order using a depth first search with
// pre-order visitation.
sp_ClearStack(theEmbedding->theStack);
sp_Push(theEmbedding->theStack, root);
while (!sp_IsEmpty(theEmbedding->theStack))
{
sp_Pop(theEmbedding->theStack, W);
P = theEmbedding->V[W].DFSParent;
V = context->V[W].ancestor;
C = context->V[W].ancestorChild;
// For the special case that we just popped the DFS tree root,
// we simply add the root to its own position.
if (P == NIL)
{
// Put the DFS root in the list by itself
LCAppend(theOrder, NIL, W);
// The children of the DFS root have the root as their
// ancestorChild and 'beyond' as the drawingFlag, so this
// causes the root's children to be placed below the root
context->V[W].drawingFlag = DRAWINGFLAG_BELOW;
}
// Determine vertex W position relative to P
else
{
// An unresolved tie is an error
if (context->V[W].drawingFlag == DRAWINGFLAG_TIE)
return NOTOK;
// If C below V, then P below V, so interpret W between
// P and V as W above P, and interpret W beyond P relative
// to V as W below P.
if (context->V[C].drawingFlag == DRAWINGFLAG_BELOW)
{
if (context->V[W].drawingFlag == DRAWINGFLAG_BETWEEN)
context->V[W].drawingFlag = DRAWINGFLAG_ABOVE;
else
context->V[W].drawingFlag = DRAWINGFLAG_BELOW;
}
// If C above V, then P above V, so interpret W between
// P and V as W below P, and interpret W beyond P relative
// to V as W above P.
else
{
if (context->V[W].drawingFlag == DRAWINGFLAG_BETWEEN)
context->V[W].drawingFlag = DRAWINGFLAG_BELOW;
else
context->V[W].drawingFlag = DRAWINGFLAG_ABOVE;
}
if (context->V[W].drawingFlag == DRAWINGFLAG_BELOW)
LCInsertAfter(theOrder, P, W);
else
LCInsertBefore(theOrder, P, W);
}
// Push DFS children
J = gp_GetFirstArc(theEmbedding, W);
while (gp_IsArc(theEmbedding, J))
{
if (theEmbedding->G[J].type == EDGE_DFSCHILD)
sp_Push(theEmbedding->theStack, theEmbedding->G[J].v);
J = gp_GetNextArc(theEmbedding, J);
}
}
// Use the order to assign vertical positions
V = root;
while (V != NIL)
{
context->G[V].pos = *pIndex;
(*pIndex)++;
V = LCGetNext(theOrder, root, V);
}
// Clean up and return
LCFree(&theOrder);
return OK;
}
int gp_LowpointAndLeastAncestor(graphP theGraph)
{
stackP theStack = theGraph->theStack;
int I, u, uneighbor, J, L, leastAncestor;
int totalVisited = 0;
#ifdef PROFILE
platform_time start, end;
platform_GetTime(start);
#endif
sp_ClearStack(theStack);
for (I=0; I < theGraph->N; I++)
theGraph->G[I].visited = 0;
/* This outer loop causes the connected subgraphs of a disconnected
graph to be processed */
for (I=0; I < theGraph->N && totalVisited < theGraph->N; I++)
{
if (theGraph->G[I].visited)
continue;
sp_Push(theStack, I);
while (sp_NonEmpty(theStack))
{
sp_Pop(theStack, u);
if (!theGraph->G[u].visited)
{
/* Mark u as visited, then push it back on the stack */
theGraph->G[u].visited = 1;
totalVisited++;
sp_Push(theStack, u);
/* Push DFS children */
J = gp_GetFirstArc(theGraph, u);
while (gp_IsArc(theGraph, J))
{
if (theGraph->G[J].type == EDGE_DFSCHILD)
{
sp_Push(theStack, theGraph->G[J].v);
}
else break;
J = gp_GetNextArc(theGraph, J);
}
}
else
{
/* Start with high values because we are doing a min function */
L = leastAncestor = u;
/* Compute L and leastAncestor */
J = gp_GetFirstArc(theGraph, u);
while (gp_IsArc(theGraph, J))
{
uneighbor = theGraph->G[J].v;
if (theGraph->G[J].type == EDGE_DFSCHILD)
{
if (L > theGraph->V[uneighbor].Lowpoint)
L = theGraph->V[uneighbor].Lowpoint;
}
else if (theGraph->G[J].type == EDGE_BACK)
{
if (leastAncestor > uneighbor)
leastAncestor = uneighbor;
}
else if (theGraph->G[J].type == EDGE_FORWARD)
break;
J = gp_GetNextArc(theGraph, J);
}
/* Assign leastAncestor and Lowpoint to the vertex */
theGraph->V[u].leastAncestor = leastAncestor;
theGraph->V[u].Lowpoint = leastAncestor < L ? leastAncestor : L;
}
}
}
#ifdef PROFILE
platform_GetTime(end);
printf("Lowpoint in %.3lf seconds.\n", platform_GetDuration(start,end));
#endif
return OK;
}
int _MarkHighestXYPath(graphP theGraph)
{
int J, Z;
int R, X, Y, W;
int stackBottom1, stackBottom2;
/* Initialization */
R = theGraph->IC.r;
X = theGraph->IC.x;
Y = theGraph->IC.y;
W = theGraph->IC.w;
theGraph->IC.px = theGraph->IC.py = NIL;
/* Save the stack bottom before we start hiding internal edges, so
we will know how many edges to restore */
stackBottom1 = sp_GetCurrentSize(theGraph->theStack);
/* Remove the internal edges incident to vertex R */
if (_HideInternalEdges(theGraph, R) != OK)
return NOTOK;
/* Now we're going to use the stack to collect the vertices of potential
* X-Y paths, so we need to store where the hidden internal edges are
* located because we must, at times, pop the collected vertices if
* the path being collected doesn't work out. */
stackBottom2 = sp_GetCurrentSize(theGraph->theStack);
/* Walk the proper face containing R to find and mark the highest
X-Y path. Note that if W is encountered, then there is no
intervening X-Y path, so we would return FALSE in that case. */
Z = R;
// This setting of J is the arc equivalent of prevLink=1
// As loop progresses, J indicates the arc used to enter Z, not the exit arc
J = gp_GetLastArc(theGraph, R);
while (theGraph->G[Z].type != VERTEX_HIGH_RYW &&
theGraph->G[Z].type != VERTEX_LOW_RYW)
{
/* Advance J and Z along the proper face containing R */
J = gp_GetPrevArcCircular(theGraph, J);
Z = theGraph->G[J].v;
J = gp_GetTwinArc(theGraph, J);
/* If Z is already visited, then pop everything since the last time
we visited Z because its all part of a separable component. */
if (theGraph->G[Z].visited)
{
if (_PopAndUnmarkVerticesAndEdges(theGraph, Z, stackBottom2) != OK)
return NOTOK;
}
/* If we have not visited this vertex before... */
else
{
/* If we find W, then there is no X-Y path. Never happens
for Kuratowski subgraph isolator, but this routine is
also used to test for certain X-Y paths.
So, we clean up and bail out in that case. */
if (Z == W)
{
if (_PopAndUnmarkVerticesAndEdges(theGraph, NIL, stackBottom2) != OK)
return NOTOK;
break;
}
/* If we found another vertex along the RXW path, then blow off
all the vertices we visited so far because they're not part of
the obstructing path */
if (theGraph->G[Z].type == VERTEX_HIGH_RXW ||
theGraph->G[Z].type == VERTEX_LOW_RXW)
{
theGraph->IC.px = Z;
if (_PopAndUnmarkVerticesAndEdges(theGraph, NIL, stackBottom2) != OK)
return NOTOK;
}
/* Push the current vertex onto the stack of vertices visited
since the last RXW vertex was encountered */
sp_Push(theGraph->theStack, J);
sp_Push(theGraph->theStack, Z);
/* Mark the vertex Z as visited as well as its edge of entry
(except the entry edge for P_x).*/
theGraph->G[Z].visited = 1;
if (Z != theGraph->IC.px)
{
theGraph->G[J].visited = 1;
theGraph->G[gp_GetTwinArc(theGraph, J)].visited = 1;
}
/* If we found an RYW vertex, then we have successfully finished
identifying the highest X-Y path, so we record the point of
attachment and break the loop. */
if (theGraph->G[Z].type == VERTEX_HIGH_RYW ||
theGraph->G[Z].type == VERTEX_LOW_RYW)
{
theGraph->IC.py = Z;
break;
}
}
}
/* Remove any remaining vertex-edge pairs on the top of the stack, then
Restore the internal edges incident to R that were previously removed. */
sp_SetCurrentSize(theGraph->theStack, stackBottom2);
if (_RestoreInternalEdges(theGraph, stackBottom1) != OK)
return NOTOK;
/* Return the result */
return theGraph->IC.py==NIL ? FALSE : TRUE;
}
int _CheckEmbeddingFacialIntegrity(graphP theGraph)
{
stackP theStack = theGraph->theStack;
int EsizeOccupied, v, e, eTwin, eStart, eNext, NumFaces, connectedComponents;
if (theGraph == NULL)
return NOTOK;
/* The stack need only contain 2M entries, one for each edge record. With
max M at 3N, this amounts to 6N integers of space. The embedding
structure already contains this stack, so we just make sure it
starts out empty. */
sp_ClearStack(theStack);
/* Push all arcs and set them to unvisited */
EsizeOccupied = gp_EdgeInUseIndexBound(theGraph);
for (e = gp_GetFirstEdge(theGraph); e < EsizeOccupied; e+=2)
{
// Except skip edge holes
if (gp_EdgeInUse(theGraph, e))
{
sp_Push(theStack, e);
gp_ClearEdgeVisited(theGraph, e);
eTwin = gp_GetTwinArc(theGraph, e);
sp_Push(theStack, eTwin);
gp_ClearEdgeVisited(theGraph, eTwin);
}
}
// There are M edges, so we better have pushed 2M arcs just now
// i.e. testing that the continue above skipped only edge holes
if (sp_GetCurrentSize(theStack) != 2*theGraph->M)
return NOTOK;
/* Read faces until every arc is used */
NumFaces = 0;
while (sp_NonEmpty(theStack))
{
/* Get an arc; if it has already been used by a face, then
don't use it to traverse a new face */
sp_Pop(theStack, eStart);
if (gp_GetEdgeVisited(theGraph, eStart)) continue;
e = eStart;
do {
eNext = gp_GetNextArcCircular(theGraph, gp_GetTwinArc(theGraph, e));
if (gp_GetEdgeVisited(theGraph, eNext))
return NOTOK;
gp_SetEdgeVisited(theGraph, eNext);
e = eNext;
} while (e != eStart);
NumFaces++;
}
/* Count the external face once rather than once per connected component;
each connected component is detected by the fact that it has no
DFS parent, except in the case of isolated vertices, no face was counted
so we do not subtract one. */
connectedComponents = 0;
for (v = gp_GetFirstVertex(theGraph); gp_VertexInRange(theGraph, v); v++)
{
if (gp_IsDFSTreeRoot(theGraph, v))
{
if (gp_GetVertexDegree(theGraph, v) > 0)
NumFaces--;
connectedComponents++;
}
}
NumFaces++;
/* Test number of faces using the extended Euler's formula.
For connected components, Euler's formula is f=m-n+2, but
for disconnected graphs it is extended to f=m-n+1+c where
c is the number of connected components.*/
return NumFaces == theGraph->M - theGraph->N + 1 + connectedComponents
? OK : NOTOK;
}
