void merge_ranks(graph_t* subg)
{
int i,d,r,pos,ipos;
node_t *v;
graph_t *root;
root = subg->root;
if (subg->u.minrank > 0)
root->u.rank[subg->u.minrank-1].valid = FALSE;
for (r = subg->u.minrank; r <= subg->u.maxrank; r++) {
d = subg->u.rank[r].n;
ipos = pos = subg->u.rankleader[r]->u.order;
make_slots(root,r,pos,d);
for (i = 0; i < subg->u.rank[r].n; i++) {
v = root->u.rank[r].v[pos] = subg->u.rank[r].v[i];
v->u.order = pos++;
v->graph = subg->root;
delete_fast_node(subg,v);
fast_node(subg->root,v);
subg->root->u.n_nodes++;
}
subg->u.rank[r].v = root->u.rank[r].v + ipos;
root->u.rank[r].valid = FALSE;
}
if (r < root->u.maxrank) root->u.rank[r].valid = FALSE;
subg->u.expanded = TRUE;
}
static void mergevirtual(graph_t * g, int r, int lpos, int rpos, int dir)
{
int i, k;
node_t *left, *right;
edge_t *e, *f, *e0;
left = GD_rank(g)[r].v[lpos];
/* merge all right nodes into the leftmost one */
for (i = lpos + 1; i <= rpos; i++) {
right = GD_rank(g)[r].v[i];
if (dir == DOWN) {
while ((e = ND_out(right).list[0])) {
for (k = 0; (f = ND_out(left).list[k]); k++)
if (f->head == e->head)
break;
if (f == NULL)
f = virtual_edge(left, e->head, e);
while ((e0 = ND_in(right).list[0])) {
merge_oneway(e0, f);
/*ED_weight(f) += ED_weight(e0); */
delete_fast_edge(e0);
}
delete_fast_edge(e);
}
} else {
while ((e = ND_in(right).list[0])) {
for (k = 0; (f = ND_in(left).list[k]); k++)
if (f->tail == e->tail)
break;
if (f == NULL)
f = virtual_edge(e->tail, left, e);
while ((e0 = ND_out(right).list[0])) {
merge_oneway(e0, f);
delete_fast_edge(e0);
}
delete_fast_edge(e);
}
}
assert(ND_in(right).size + ND_out(right).size == 0);
delete_fast_node(g, right);
}
k = lpos + 1;
i = rpos + 1;
while (i < GD_rank(g)[r].n) {
node_t *n;
n = GD_rank(g)[r].v[k] = GD_rank(g)[r].v[i];
ND_order(n) = k;
k++;
i++;
}
GD_rank(g)[r].n = k;
GD_rank(g)[r].v[k] = NULL;
}
static void
merge_ranks(graph_t * subg)
{
int i, d, r, pos, ipos;
node_t *v;
graph_t *root;
root = agroot(subg);
if (GD_minrank(subg) > 0)
#ifndef WITH_CGRAPH
ND_rank(root)[GD_minrank(subg) - 1].valid = FALSE;
#else /* WITH_CGRAPH */
GD_rank(root)[GD_minrank(subg) - 1].valid = FALSE;
#endif /* WITH_CGRAPH */
for (r = GD_minrank(subg); r <= GD_maxrank(subg); r++) {
d = GD_rank(subg)[r].n;
#ifndef WITH_CGRAPH
ipos = pos = GD_rankleader(subg)[r]->u.order;
#else /* WITH_CGRAPH */
ipos = pos = ND_order(GD_rankleader(subg)[r]);
#endif /* WITH_CGRAPH */
make_slots(root, r, pos, d);
for (i = 0; i < GD_rank(subg)[r].n; i++) {
#ifndef WITH_CGRAPH
v = ND_rank(root)[r].v[pos] = GD_rank(subg)[r].v[i];
#else /* WITH_CGRAPH */
v = GD_rank(root)[r].v[pos] = GD_rank(subg)[r].v[i];
#endif /* WITH_CGRAPH */
ND_order(v) = pos++;
#ifndef WITH_CGRAPH
v->graph = subg->root;
#else /* WITH_CGRAPH */
/* real nodes automatically have v->root = root graph */
if (ND_node_type(v) == VIRTUAL)
v->root = root;
#endif /* WITH_CGRAPH */
delete_fast_node(subg, v);
fast_node(agroot(subg), v);
GD_n_nodes(agroot(subg))++;
}
#ifndef WITH_CGRAPH
GD_rank(subg)[r].v = ND_rank(root)[r].v + ipos;
ND_rank(root)[r].valid = FALSE;
#else /* WITH_CGRAPH */
GD_rank(subg)[r].v = GD_rank(root)[r].v + ipos;
GD_rank(root)[r].valid = FALSE;
#endif /* WITH_CGRAPH */
}
if (r < GD_maxrank(root))
GD_rank(root)[r].valid = FALSE;
GD_expanded(subg) = TRUE;
}
void remove_rankleaders(graph_t* g)
{
int r;
node_t *v;
edge_t *e;
for (r = g->u.minrank; r <= g->u.maxrank; r++) {
v = g->u.rankleader[r];
/* remove the entire chain */
while ((e = v->u.out.list[0])) delete_fast_edge(e);
while ((e = v->u.in.list[0])) delete_fast_edge(e);
delete_fast_node(g->root,v);
g->u.rankleader[r] = NULL;
}
}
/* removeFill:
* This removes all of the fill nodes added in mincross.
* It appears to be sufficient to remove them only from the
* rank array and fast node list of the root graph.
*/
static void
removeFill (Agraph_t * g)
{
Agnode_t* n;
Agnode_t* nxt;
Agraph_t* sg = agsubg (g, "_new_rank", 0);
if (!sg) return;
for (n = agfstnode(sg); n; n = nxt) {
nxt = agnxtnode(sg, n);
delete_fast_node (g, n);
remove_from_rank (g, n);
dot_cleanup_node (n);
agdelnode(g, n);
}
agdelsubg (g, sg);
}
static void
remove_rankleaders(graph_t * g)
{
int r;
node_t *v;
edge_t *e;
for (r = GD_minrank(g); r <= GD_maxrank(g); r++) {
v = GD_rankleader(g)[r];
/* remove the entire chain */
while ((e = ND_out(v).list[0]))
delete_fast_edge(e);
while ((e = ND_in(v).list[0]))
delete_fast_edge(e);
delete_fast_node(agroot(g), v);
GD_rankleader(g)[r] = NULL;
}
}
