/** Determine the current active state.
* Note that there might be multiple active states if there are sub-fsms. It will
* only consider the active state of the bottom-fsm.
* @return the current active state
*/
std::string
SkillGuiGraphDrawingArea::get_active_state(graph_t *graph)
{
if (! graph) {
return "";
}
// Loop through the nodes in the graph/subgraph and find the active node
for (node_t *n = agfstnode(graph); n; n = agnxtnode(graph, n)) {
const char *actattr = agget(n, (char *)"active");
if (actattr && (strcmp(actattr, "true") == 0) ) {
node_t *mn = agmetanode(graph);
graph_t *mg = mn->graph;
// Check to see if the node has an edge going into a subgraph
for (edge_t *me = agfstout(mg, mn); me; me = agnxtout(mg, me)) {
graph_t *subgraph = agusergraph(me->head);
for (edge_t *e = agfstout(graph, n); e; e = agnxtout(graph, e)) {
for (node_t *subnode = agfstnode(subgraph); subnode; subnode = agnxtnode(subgraph, subnode)) {
if (agnameof(subnode) == agnameof(e->head)) {
// The node goes into a subgraph, recursively find and return the active subnode name
return get_active_state(subgraph);
}
}
}
}
// The node has no subgraph, return the name of the active node
return agnameof(n);
}
}
return "";
}
static void
cleanup1(graph_t * g)
{
node_t *n;
edge_t *e, *f;
int c;
for (c = 0; c < GD_comp(g).size; c++) {
GD_nlist(g) = GD_comp(g).list[c];
for (n = GD_nlist(g); n; n = ND_next(n)) {
renewlist(&ND_in(n));
renewlist(&ND_out(n));
ND_mark(n) = FALSE;
}
}
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
f = ED_to_virt(e);
/* Null out any other references to f to make sure we don't
* handle it a second time. For example, parallel multiedges
* share a virtual edge.
*/
if (f && (e == ED_to_orig(f))) {
edge_t *e1, *f1;
#ifndef WITH_CGRAPH
for (e1 = agfstout(g, n); e1; e1 = agnxtout(g, e1)) {
if (e != e1) {
f1 = ED_to_virt(e1);
if (f1 && (f == f1)) {
ED_to_virt(e1) = NULL;
}
}
}
#else
node_t *n1;
for (n1 = agfstnode(g); n1; n1 = agnxtnode(g, n1)) {
for (e1 = agfstout(g, n1); e1; e1 = agnxtout(g, e1)) {
if (e != e1) {
f1 = ED_to_virt(e1);
if (f1 && (f == f1)) {
ED_to_virt(e1) = NULL;
}
}
}
}
free(f->base.data);
#endif
free(f);
}
ED_to_virt(e) = NULL;
}
}
free(GD_comp(g).list);
GD_comp(g).list = NULL;
GD_comp(g).size = 0;
}
void mark_lowclusters(Agraph_t * root)
{
Agnode_t *n, *vn;
Agedge_t *orig, *e;
/* first, zap any previous cluster labelings */
for (n = agfstnode(root); n; n = agnxtnode(root, n)) {
ND_clust(n) = NULL;
for (orig = agfstout(root, n); orig; orig = agnxtout(root, orig)) {
if ((e = ED_to_virt(orig))) {
#ifndef WITH_CGRAPH
while (e && (vn = e->head)->u.node_type == VIRTUAL) {
#else /* WITH_CGRAPH */
while (e && (ND_node_type(vn = aghead(e))) == VIRTUAL) {
#endif /* WITH_CGRAPH */
ND_clust(vn) = NULL;
e = ND_out(aghead(e)).list[0];
}
}
}
}
/* do the recursion */
mark_lowcluster_basic(root);
}
static void mark_lowcluster_basic(Agraph_t * g)
{
Agraph_t *clust;
Agnode_t *n, *vn;
Agedge_t *orig, *e;
int c;
for (c = 1; c <= GD_n_cluster(g); c++) {
clust = GD_clust(g)[c];
mark_lowcluster_basic(clust);
}
/* see what belongs to this graph that wasn't already marked */
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (ND_clust(n) == NULL)
ND_clust(n) = g;
for (orig = agfstout(g, n); orig; orig = agnxtout(g, orig)) {
if ((e = ED_to_virt(orig))) {
#ifndef WITH_CGRAPH
while (e && (vn = e->head)->u.node_type == VIRTUAL) {
#else /* WITH_CGRAPH */
while (e && (ND_node_type(vn = aghead(e))) == VIRTUAL) {
#endif /* WITH_CGRAPH */
if (ND_clust(vn) == NULL)
ND_clust(vn) = g;
e = ND_out(aghead(e)).list[0];
}
}
}
}
}
/* clone_graph:
* Create two copies of the argument graph
* One is a subgraph, the other is an actual copy since we will be
* adding edges to it.
*/
static Agraph_t*
clone_graph(Agraph_t* ing, Agraph_t** xg)
{
Agraph_t* clone;
Agraph_t* xclone;
Agnode_t* n;
Agnode_t* xn;
Agnode_t* xh;
Agedge_t* e;
Agedge_t* xe;
char gname[SMALLBUF];
static int id = 0;
sprintf (gname, "_clone_%d", id++);
clone = agsubg(ing, gname);
sprintf (gname, "_clone_%d", id++);
xclone = agopen(gname, ing->kind);
for(n = agfstnode(ing); n; n = agnxtnode(ing, n)) {
aginsert (clone, n);
xn = agnode (xclone, n->name);
CLONE(n) = xn;
}
for(n = agfstnode(ing); n; n = agnxtnode(ing, n)) {
xn = CLONE(n);
for(e = agfstout(ing, n); e; e = agnxtout(ing, e)) {
aginsert (clone, e);
xh = CLONE(e->head);
xe = agedge (xclone, xn, xh);
ORIGE(xe) = e;
DEGREE(xn) += 1;
DEGREE(xh) += 1;
}
}
*xg = xclone;
#ifdef OLD
clone = agopen("clone", root->kind);
for(n = agfstnode(root); n; n = agnxtnode(root, n)) {
cn = agnode(clone, n->name);
ND_alg(cn) = DATA(n);
BCDONE(cn) = 0;
}
for(n = agfstnode(root); n; n = agnxtnode(root, n)) {
Agnode_t *t = agnode(clone, n);
for(e = agfstout(root, n); e; e = agnxtout(root, e)) {
Agnode_t *h = agnode(clone, e->head->name);
agedge(clone, t, h);
}
}
#endif
return clone;
}
static cluster_data* cluster_map(graph_t *mastergraph, graph_t *g)
{
/* search meta-graph to find clusters */
graph_t *mg, *subg;
node_t *mm, *mn;
node_t *n;
edge_t *me;
/* array of arrays of node indices in each cluster */
int **cs,*cn;
int i,j,nclusters=0;
bool* assigned = N_NEW(agnnodes(g), bool);
cluster_data *cdata = GNEW(cluster_data);
cdata->ntoplevel = agnnodes(g);
mm = mastergraph->meta_node;
mg = mm->graph;
for (me = agfstout(mg, mm); me; me = agnxtout(mg, me)) {
mn = me->head;
subg = agusergraph(mn);
if (!strncmp(subg->name, "cluster", 7)) {
nclusters++;
}
}
cdata->nvars=0;
cdata->nclusters = nclusters;
cs = cdata->clusters = N_GNEW(nclusters,int*);
cn = cdata->clustersizes = N_GNEW(nclusters,int);
/* fprintf(stderr,"search %d clusters...\n",nclusters); */
for (me = agfstout(mg, mm); me; me = agnxtout(mg, me)) {
mn = me->head;
subg = agusergraph(mn);
/* clusters are processed by separate calls to ordered_edges */
if (!strncmp(subg->name, "cluster", 7)) {
int *c;
*cn = agnnodes(subg);
cdata->nvars += *cn;
c = *cs++ = N_GNEW(*cn++,int);
/* fprintf(stderr,"Cluster with %d nodes...\n",agnnodes(subg)); */
for (n = agfstnode(subg); n; n = agnxtnode(subg, n)) {
node_t *gn;
int ind = 0;
for (gn = agfstnode(g); gn; gn = agnxtnode(g, gn)) {
if(gn->id==n->id) break;
ind++;
}
/* fprintf(stderr," node=%s, id=%d, ind=%d\n",n->name,n->id,ind); */
*c++=ind;
assigned[ind]=true;
cdata->ntoplevel--;
}
}
}
static void
mapGraphs (graph_t * g, graph_t * cg, distfn dist)
{
node_t *n;
edge_t *e;
edge_t *ce;
node_t *t;
node_t *h;
nitem *tp;
nitem *hp;
int delta;
for (n = agfstnode (g); n; n = agnxtnode (g, n))
{
for (e = agfstout (g, n); e; e = agnxtout (g, e))
{
delta = dist (&tp->bb, &hp->bb);
ce = agedge (cg, t, h, ((void *) 0), 1);
if ((((Agedgeinfo_t *) (((Agobj_t *) (ce))->data))->minlen) < delta)
{
if ((((Agedgeinfo_t *) (((Agobj_t *) (ce))->data))->minlen) ==
0.0)
{
}
}
}
}
}
/*-------------------------------------------------------------------------*\
* Method: n.degree(self, what)
* Determines degree of a node.
* Returns number of in-edges (what='*i'), out-edges (what='*o') or the sum
* of all edges (what='*a') to/from/of a node.
* Example:
* rv, err = n:degree("*i")
\*-------------------------------------------------------------------------*/
int gr_degree(lua_State *L)
{
int count = 0;
Agedge_t *e;
Agraph_t *g;
Agnode_t *n;
gr_node_t *ud = tonode(L, 1, STRICT);
char *flag = (char *) luaL_optstring(L, 2, "*a");
int indeg = TRUE;
int outdeg = TRUE;
n = ud->n;
g = agroot(ud->n);
if (*flag != '*'){
luaL_error(L, "invalid format specifier");
return 0;
}
switch(*(flag+1)){
case 'i': outdeg = FALSE; break;
case 'o': indeg = FALSE; break;
}
if (indeg){
for (e = agfstin(g, n); e; e = agnxtin(g, e)){
count++;
}
}
if (outdeg){
for (e = agfstout(g, n); e; e = agnxtout(g, e)){
count++;
}
}
lua_pushnumber(L, count);
return 1;
}
/* dfs:
* Return the number of reversed edges for this component.
*/
static int dfs(Agraph_t * g, Agnode_t * t, int hasCycle)
{
Agedge_t *e;
Agedge_t *f;
Agnode_t *h;
ND_mark(t) = 1;
ND_onstack(t) = 1;
for (e = agfstout(g, t); e; e = f) {
f = agnxtout(g, e);
if (agtail(e) == aghead(e))
continue;
h = aghead(e);
if (ND_onstack(h)) {
if (agisstrict(g)) {
if (agedge(g, h, t, 0, 0) == 0)
addRevEdge(g, e);
} else {
char* key = agnameof (e);
if (!key || (agedge(g, h, t, key, 0) == 0))
addRevEdge(g, e);
}
agdelete(g, e);
hasCycle = 1;
} else if (ND_mark(h) == 0)
hasCycle |= dfs(g, h, hasCycle);
}
ND_onstack(t) = 0;
return hasCycle;
}
void fdp_init_node_edge(graph_t * g)
{
attrsym_t *E_len;
node_t *n;
edge_t *e;
int nn = agnnodes(g);
int i;
ndata* alg = N_NEW(nn, ndata);
processClusterEdges(g);
GD_neato_nlist(g) = N_NEW(nn + 1, node_t *);
for (i = 0, n = agfstnode(g); n; n = agnxtnode(g, n)) {
neato_init_node (n);
ND_alg(n) = alg + i;
GD_neato_nlist(g)[i] = n;
ND_id(n) = i++;
}
E_len = agfindattr(g->proto->e, "len");
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
init_edge(e, E_len);
}
}
initialPositions(g);
}
void QGVScene::loadLayout(const QString &text)
{
_graph->setGraph(QGVCore::agmemread2(text.toLocal8Bit().constData()));
if(gvLayout(_context->context(), _graph->graph(), "dot") != 0)
{
qCritical()<<"Layout render error"<<agerrors()<<QString::fromLocal8Bit(aglasterr());
return;
}
//Debug output
//gvRenderFilename(_context->context(), _graph->graph(), "png", "debug.png");
//Read nodes and edges
for (Agnode_t* node = agfstnode(_graph->graph()); node != NULL; node = agnxtnode(_graph->graph(), node))
{
QGVNode *inode = new QGVNode(new QGVNodePrivate(node), this);
inode->updateLayout();
addItem(inode);
_nodes.append (inode);
for (Agedge_t* edge = agfstout(_graph->graph(), node); edge != NULL; edge = agnxtout(_graph->graph(), edge))
{
QGVEdge *iedge = new QGVEdge(new QGVEdgePrivate(edge), this);
iedge->updateLayout();
addItem(iedge);
_edges.append (iedge);
}
}
update();
}
void build_skeleton(graph_t *g, graph_t *subg)
{
int r;
node_t *v,*prev,*rl;
edge_t *e;
prev = NULL;
subg->u.rankleader = N_NEW(subg->u.maxrank + 2,node_t*);
for (r = subg->u.minrank; r <= subg->u.maxrank; r++) {
v = subg->u.rankleader[r] = virtual_node(g);
v->u.rank = r;
v->u.ranktype = CLUSTER;
v->u.clust = subg;
if (prev) {
e = virtual_edge(prev,v,NULL);
e->u.xpenalty *= CL_CROSS;
}
prev = v;
}
/* set the counts on virtual edges of the cluster skeleton */
for (v = agfstnode(subg); v; v = agnxtnode(subg,v)) {
rl = subg->u.rankleader[v->u.rank];
rl->u.UF_size++;
for (e = agfstout(subg,v); e; e = agnxtout(subg,e)) {
for (r = e->tail->u.rank; r < e->head->u.rank; r++) {
rl->u.out.list[0]->u.count++;
}
}
}
for (r = subg->u.minrank; r <= subg->u.maxrank; r++) {
rl = subg->u.rankleader[r];
if (rl->u.UF_size > 1) rl->u.UF_size--;
}
}
static void freeDerivedGraph(graph_t * g, graph_t ** cc)
{
graph_t *cg;
node_t *dn;
node_t *dnxt;
edge_t *e;
while ((cg = *cc++)) {
freeGData(cg);
agdelrec(cg, "Agraphinfo_t");
}
if (PORTS(g))
free(PORTS(g));
freeGData(g);
agdelrec(g, "Agraphinfo_t");
for (dn = agfstnode(g); dn; dn = dnxt) {
dnxt = agnxtnode(g, dn);
for (e = agfstout(g, dn); e; e = agnxtout(g, e)) {
free (ED_to_virt(e));
agdelrec(e, "Agedgeinfo_t");
}
freeDeriveNode(dn);
}
agclose(g);
}
void
dumpstat (graph_t* g)
{
double dx, dy;
double l, max2 = 0.0;
node_t* np;
edge_t* ep;
for (np = agfstnode(g); np; np = agnxtnode(g,np)) {
dx = DISP(np)[0];
dy = DISP(np)[1];
l = dx*dx + dy*dy;
if (l > max2) max2 = l;
fprintf (stderr, "%s: (%f,%f) (%f,%f)\n", np->name,
ND_pos(np)[0], ND_pos(np)[1],
DISP(np)[0], DISP(np)[1]);
}
fprintf (stderr, "max delta = %f\n", sqrt(max2));
for (np = agfstnode(g); np; np = agnxtnode(g,np)) {
for (ep = agfstout(g,np); ep; ep = agnxtout(g,ep)) {
dx = ND_pos(np)[0] - ND_pos(ep->head)[0];
dy = ND_pos(np)[1] - ND_pos(ep->head)[1];
fprintf (stderr, " %s -- %s (%f)\n", np->name, ep->head->name,
sqrt(dx*dx + dy*dy));
}
}
}
/* mapGraphs:
*/
static void mapGraphs(graph_t * g, graph_t * cg, distfn dist)
{
node_t *n;
edge_t *e;
edge_t *ce;
node_t *t;
node_t *h;
nitem *tp;
nitem *hp;
int delta;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
tp = (nitem *) ND_alg(n);
t = tp->cnode;
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
hp = (nitem *) ND_alg(e->head);
delta = dist(&tp->bb, &hp->bb);
h = hp->cnode;
ce = agedge(cg, t, h);
ED_weight(ce) = 1;
if (ED_minlen(ce) < delta) {
if (ED_minlen(ce) == 0.0) {
elist_append(ce, ND_out(t));
elist_append(ce, ND_in(h));
}
ED_minlen(ce) = delta;
}
}
}
}
grafo le_grafo(FILE *input){
if (!input)
return NULL;
Agraph_t *Ag = agread(input, NULL);
if(!Ag)
return NULL;
grafo g = cria_grafo(agnameof(Ag), agisdirected(Ag), contem_pesos(Ag), agnnodes(Ag));
for (Agnode_t *Av=agfstnode(Ag); Av; Av=agnxtnode(Ag,Av)) {
cria_vertice(g, agnameof(Av));
}
for (Agnode_t *Av=agfstnode(Ag); Av; Av=agnxtnode(Ag,Av)) {
for (Agedge_t *Ae=agfstout(Ag,Av); Ae; Ae=agnxtout(Ag,Ae)) {
vertice u = v_busca(g, agnameof(agtail(Ae)));
vertice v = v_busca(g, agnameof(aghead(Ae)));
cria_vizinhanca(g, u, v, get_peso(Ae));
}
}
agclose(Ag);
agfree(Ag, NULL);
return g;
}
/* processClusterEdges:
* Look for cluster edges. Replace cluster edge endpoints
* corresponding to a cluster with special cluster nodes.
* Delete original nodes.
* Return 0 if no cluster edges; 1 otherwise.
*/
int processClusterEdges(graph_t * g)
{
int rv;
node_t *n;
node_t *nxt;
edge_t *e;
graph_t *clg;
agxbuf xb;
Dt_t *map;
Dt_t *cmap = mkClustMap (g);
unsigned char buf[SMALLBUF];
map = dtopen(&mapDisc, Dtoset);
clg = agsubg(g, "__clusternodes",1);
agbindrec(clg, "Agraphinfo_t", sizeof(Agraphinfo_t), TRUE);
agxbinit(&xb, SMALLBUF, buf);
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (IS_CLUST_NODE(n)) continue;
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
checkCompound(e, clg, &xb, map, cmap);
}
}
agxbfree(&xb);
dtclose(map);
rv = agnnodes(clg);
for (n = agfstnode(clg); n; n = nxt) {
nxt = agnxtnode(clg, n);
agdelete(g, n);
}
agclose(clg);
if (rv)
SET_CLUST_EDGE(g);
dtclose(cmap);
return rv;
}
static int out_cross(node_t *v, node_t *w)
{
register edge_t *e1,*e2;
register int inv, cross = 0,t;
for (e2 = agfstout(w->graph,w); e2; e2 = agnxtout(w->graph,e2)) {
register int cnt = ED_xpenalty(e2);
inv = ND_order(e2->head);
for (e1 = agfstout(v->graph,v); e1; e1 = agnxtout(v->graph,e1)) {
t = ND_order(e1->head) - inv;
if ((t > 0) || ((t == 0) && (ED_headport(e1).p.x > ED_headport(e2).p.x)))
cross += ED_xpenalty(e1) * cnt;
}
}
return cross;
}
/*
populates rank lists of g. there are some key details:
1) the input graph ordering must be respected (in left to right initialization)
2) connected components are separated and marked with indices
3) series-parallel graphs (includes trees, obviously) must not have crossings
*/
static void build_ranks(Agraph_t *g, boolean down)
{
queue *q;
component_t c;
int r;
Agnode_t *n;
Agedge_t *e;
c = build_components(g, down);
/* process each each component */
q = new_queue(agnnodes(g)+1);
for (r = 0; r < c.r; r++) {
enqueue(q,c.root[r]);
if ((r + 1 >= c.r)||(ND_component(c.root[r])!=ND_component(c.root[r+1]))) {
while ((n = dequeue(q))) {
install(g,n);
if (down) {
for (e = agfstout(g,n); e; e = agnxtout(g,e))
if (--ND_priority(e->head) == 0) enqueue(q,e->head);
}
else {
for (e = agfstin(g,n); e; e = agnxtin(g,e))
if (--ND_priority(e->tail) == 0) enqueue(q,e->head);
}
}
}
}
free_queue(q);
}
static int dfs(Agraph_t * g, Agnode_t * t, int hasCycle)
{
Agedge_t *e;
Agedge_t *f;
Agnode_t *h;
ND_mark(t) = 1;
ND_onstack(t) = 1;
for (e = agfstout(g, t); e; e = f) {
f = agnxtout(g, e);
if (e->tail == e->head)
continue;
h = e->head;
if (ND_onstack(h)) {
if (AG_IS_STRICT(g)) {
if (agfindedge(g, h, t) == 0)
addRevEdge(g, e);
} else
addRevEdge(g, e);
agdelete(g, e);
hasCycle = 1;
} else if (ND_mark(h) == 0)
hasCycle = dfs(g, h, hasCycle);
}
ND_onstack(t) = 0;
return hasCycle;
}
int main() {
FILE * fp = fopen("test", "r");
assert(fp);
Agraph_t * graph = agread(fp, NULL);
assert(graph);
printf("Number of nodes is %d\n", agnnodes(graph));
printf("Number of edges is %d\n", agnedges(graph));
/* Iterate through nodes */
Agnode_t * node = agfstnode(graph);
while (node != NULL) {
assert(node);
printf("Iterating through yet another node\n");
char * label = agget(node, "label");
printf("Node label is %s\n", label);
Agedge_t * edge = agfstout(graph, node);
while (edge != NULL) {
assert(edge);
printf("Iterating through yet another edge \n");
assert(agtail(edge) == node);
edge = agnxtout(graph, edge);
}
/* Move on to the next node */
printf("\n");
node = agnxtnode(graph, node);
}
/* Free graph structure */
agclose(graph);
return 0;
}
void remove_child(Agraph_t * graph, Agnode_t * node)
{
Agedge_t *edge;
Agedge_t *nexte;
/* Avoid cycles */
if MARKED
(node) return;
MARK(node);
/* Skip nodes with more than one parent */
edge = agfstin(node);
if (edge && (agnxtin(edge) != NULL)) {
UNMARK(node);
return;
}
/* recursively remove children */
for (edge = agfstout(node); edge; edge = nexte) {
nexte = agnxtout(edge);
if (aghead(edge) != node) {
if (verbose)
fprintf(stderr, "Processing descendant: %s\n",
agnameof(aghead(edge)));
remove_child(graph, aghead(edge));
agdeledge(edge);
}
}
agdelnode(node);
return;
}
static void
gv_to_gml(Agraph_t* G, FILE* outFile)
{
Agnode_t* n;
Agedge_t* e;
fprintf (outFile, "graph [\n version 2\n");
if (agisdirected(G))
fprintf (outFile, " directed 1\n");
else
fprintf (outFile, " directed 0\n");
emitGraphAttrs (G, outFile);
/* FIX: Not sure how to handle default attributes or subgraphs */
for (n = agfstnode(G); n; n = agnxtnode (G, n)) {
emitNode (G, n, outFile);
}
for (n = agfstnode(G); n; n = agnxtnode (G, n)) {
for (e = agfstout(G, n); e; e = agnxtout (G, e)) {
emitEdge (G, e, outFile);
}
}
fprintf (outFile, "]\n");
}
static void
node_induce(graph_t * par, graph_t * g)
{
node_t *n, *nn;
edge_t *e;
int i;
/* enforce that a node is in at most one cluster at this level */
for (n = agfstnode(g); n; n = nn) {
nn = agnxtnode(g, n);
if (ND_ranktype(n)) {
agdelete(g, n);
continue;
}
for (i = 1; i < GD_n_cluster(par); i++)
if (agcontains(GD_clust(par)[i], n))
break;
if (i < GD_n_cluster(par))
agdelete(g, n);
ND_clust(n) = NULL;
}
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
for (e = agfstout(dot_root(g), n); e; e = agnxtout(dot_root(g), e)) {
if (agcontains(g, aghead(e)))
agsubedge(g,e,1);
}
}
}
void GraphvizPlotter::parseEdges(Agraph_t *g, GraphComponent *g_component, processedProperties *props) {
Agnode_t *from_node = agfstnode(g);
// nacteme prvni vrchol
while (from_node) {
// nacteme hranu, ktera z vrcholu vychazi
Agedge_t *e = agfstout(g, from_node);
while (e) {
// pokud byla tato hrana uz zpracovana, preskocime
if (isWalkedObject(e, &props->edges)) {
e = agnxtout(g, e);
continue;
}
// nacteme vrchol, ke kteremu hrana vede
Agnode_t *to_node = e->node;
// pridame hranu do datoveho modelu
Edge *edge = g_component->addEdge(agnameof(from_node), agnameof(to_node));
// pridame vsechny jeho atributy
parseEdgeAttrs(e, edge, props);
// pridame mezi zpracovane
props->edges.push_back(e);
// nacteme dalsi hranu, ktera vede z daneho vrcholu
e = agnxtout(g, e);
}
// nacteme dalsi vrchol
from_node = agnxtnode(g, from_node);
}
}
/* processClusterEdges:
* Look for cluster edges. Replace cluster edge endpoints
* corresponding to a cluster with special cluster nodes.
* Delete original nodes.
* Return 0 if no cluster edges; 1 otherwise.
*/
int processClusterEdges(graph_t * g)
{
int rv;
node_t *n;
edge_t *e;
graph_t *clg;
agxbuf xb;
Dt_t *map;
unsigned char buf[SMALLBUF];
map = dtopen(&mapDisc, Dtoset);
clg = agsubg(g, "__clusternodes");
agxbinit(&xb, SMALLBUF, buf);
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
checkCompound(e, clg, &xb, map);
}
}
agxbfree(&xb);
dtclose(map);
rv = agnnodes(clg);
for (n = agfstnode(clg); n; n = agnxtnode(clg, n)) {
agdelete(g, n);
}
agclose(clg);
if (rv)
SET_CLUST_EDGE(g);
return rv;
}
static int dfs(Agnode_t * n, Agedge_t * link, int warn)
{
Agedge_t *e;
Agedge_t *f;
Agraph_t *g = agrootof(n);
MARK(n) = 1;
for (e = agfstin(g, n); e; e = f) {
f = agnxtin(g, e);
if (e == link)
continue;
if (MARK(agtail(e)))
agdelete(g, e);
}
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
if (MARK(aghead(e))) {
if (!warn) {
warn++;
fprintf(stderr,
"warning: %s has cycle(s), transitive reduction not unique\n",
agnameof(g));
fprintf(stderr, "cycle involves edge %s -> %s\n",
agnameof(agtail(e)), agnameof(aghead(e)));
}
} else
warn = dfs(aghead(e), AGOUT2IN(e), warn);
}
MARK(n) = 0;
return warn;
}
static int
eval (Agraph_t* g, int root)
{
Agraph_t* mg;
Agedge_t* me;
Agnode_t* mn;
Agraph_t* subg;
if (root && !(GTYPE(g) & gtype)) return 1;
if ((flags & CL) && root)
cl_count (g);
emit (g, root);
if (recurse) {
n_indent++;
mg = g->meta_node->graph;
for (me = agfstout(mg,g->meta_node); me; me = agnxtout(mg,me)) {
mn = me->head;
subg = agusergraph(mn);
eval (subg, 0);
}
n_indent--;
}
return 0;
}
grafo le_grafo(FILE *input) {
int i;
Agnode_t *v;
Agedge_t *a;
Agraph_t *g_cgraph;
g_cgraph = agread(input, NULL);
if ( !g_cgraph )
return NULL;
// Cria grafo
grafo g = (grafo) malloc(sizeof(struct grafo));
g->tipo = agisdirected(g_cgraph);
g->vertice = (vertice_t) malloc(agnnodes(g_cgraph) * sizeof(struct vertice_t));
//Copia nome do grafo
g->nome = (char *) malloc(strlen(agnameof(g_cgraph))+1);
strcpy(g->nome, agnameof(g_cgraph));
if (!g->vertice)
return NULL;
i = 0;
// Copia vertices
for (v=agfstnode(g_cgraph ); v; v=agnxtnode(g_cgraph ,v), i++) {
// copia nome
g->vertice[i].nome = (char *) malloc(strlen(agnameof(v))+1);
strcpy(g->vertice[i].nome, agnameof(v));
// inicializa lista de arestas
g->vertice[i].aresta = NULL;
// seta next vertice
if (i != agnnodes(g_cgraph) - 1)
g->vertice[i].next = &g->vertice[i+1];
//set atribute
Agnodeinfo_t *p;
p = (Agnodeinfo_t*) agbindrec(v,"Agnodeinfo_t",sizeof(Agnodeinfo_t),TRUE);
p->ref_v = &g->vertice[i];
}
g->vertice[i-1].next = NULL;
//Copia arestas
i = 0;
for (v=agfstnode(g_cgraph); v; v=agnxtnode(g_cgraph,v), i++) {
if (g->tipo == NAODIRECIONADO){
for (a=agfstedge(g_cgraph,v); a; a=agnxtedge(g_cgraph,a,v))
add_aresta(g, &g->vertice[i], v, a);
} else {
for (a=agfstout(g_cgraph,v); a; a=agnxtout(g_cgraph,a))
add_aresta(g, &g->vertice[i], v, a);
}
}
free(g_cgraph);
return g;
}
/* mapGraphs:
*/
static void mapGraphs(graph_t * g, graph_t * cg, distfn dist)
{
node_t *n;
edge_t *e;
edge_t *ce;
node_t *t;
node_t *h;
nitem *tp;
nitem *hp;
int delta;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
tp = (nitem *) ND_alg(n);
t = tp->cnode;
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
hp = (nitem *) ND_alg(aghead(e));
delta = dist(&tp->bb, &hp->bb);
h = hp->cnode;
#ifndef WITH_CGRAPH
ce = agedge(cg, t, h);
#else
ce = agedge(cg, t, h, NULL, 1);
agbindrec(ce, "Agedgeinfo_t", sizeof(Agedgeinfo_t), TRUE);
#endif
ED_weight(ce) = 1;
if (ED_minlen(ce) < delta) {
if (ED_minlen(ce) == 0.0) {
elist_append(ce, ND_out(t));
elist_append(ce, ND_in(h));
}
ED_minlen(ce) = delta;
}
}
}
}
static void
cloneSubg (Agraph_t* parent, Agraph_t* sg, Dt_t* emap)
{
Agraph_t* subg;
Agnode_t* t;
Agedge_t* e;
Agnode_t* newt;
Agedge_t* newe;
Agraph_t* newg;
if (is_a_cluster(sg)) {
newg = agsubg (parent, agnameof(sg), 1);
parent = newg;
for (t = agfstnode(sg); t; t = agnxtnode(sg, t)) {
newt = agnode(newg, agnameof(t), 0);
agsubnode(newg, newt, 1);
/* if e is in sg, both end points are, so we can use out edges */
for (e = agfstout(sg, t); e; e = agnxtout(sg, e)) {
newe = mapEdge (emap, e);
agsubedge(newg, newe, 1);
}
}
}
for (subg = agfstsubg(sg); subg; subg = agnxtsubg(subg)) {
cloneSubg(parent, subg, emap);
}
}