/* sizeArray:
* Set column and row sizes. Optimize for minimum width and
* height. Where there is slack, try to distribute evenly.
* We do this by encoding cells as edges with min length is
* a dag on a chain. We then run network simplex, using
* LR_balance.
*/
void sizeArray(htmltbl_t * tbl)
{
graph_t *rowg;
graph_t *colg;
/* Do the 1D cases by hand */
if ((tbl->rc == 1) || (tbl->cc == 1)) {
sizeLinearArray(tbl);
return;
}
tbl->heights = N_NEW(tbl->rc + 1, int);
tbl->widths = N_NEW(tbl->cc + 1, int);
#ifdef WITH_CGRAPH
rowg = agopen("rowg", Agdirected,NIL(Agdisc_t *));
colg = agopen("colg", Agdirected,NIL(Agdisc_t *));
/* Only need GD_nlist */
agbindrec(rowg, "Agraphinfo_t", sizeof(Agraphinfo_t), TRUE); // graph custom data
agbindrec(colg, "Agraphinfo_t", sizeof(Agraphinfo_t), TRUE); // graph custom data
#else
rowg = agopen("rowg", AGDIGRAPH);
colg = agopen("colg", AGDIGRAPH);
#endif
makeGraphs(tbl, rowg, colg);
rank(rowg, 2, INT_MAX);
rank(colg, 2, INT_MAX);
setSizes(tbl, rowg, colg);
closeGraphs(rowg, colg);
}
void GraphvizAdapterImpl::init_graph_() {
#if GRAPHVIZ_CGRAPH
g_ = agopen((char*)"g", Agdirected, NULL);
#else
g_ = agopen((char*)"g", AGDIGRAPH);
#endif
assert(g_);
}
/* 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;
}
grafo escreve_grafo(FILE *output, grafo g){
if(!g || !output)
return NULL;
Agraph_t *ag;
Agsym_t *peso;
char peso_s[MAX_STRING_SIZE];
//criando a string "peso"
char p_str[5];
strcpy(p_str, "peso");
//cria uma string vazia pra usar como valor default do atributo peso
char default_s[1];
default_s[0] = '\0';
if(g->direcionado)
ag = agopen(g->nome, Agstrictdirected, NULL);
else
ag= agopen(g->nome, Agstrictundirected, NULL);
if(g->ponderado)
peso = agattr(ag, AGEDGE, p_str, default_s);
Agnode_t **nodes = malloc(g->n_vertices * sizeof(Agnode_t*));
for(unsigned int i = 0; i < g->n_vertices; i++)
nodes[g->vertices[i]->id] = agnode(ag, g->vertices[i]->nome, TRUE);
for(unsigned int i = 0; i < g->n_vertices; i++){
vertice v = g->vertices[i];
for(no n = primeiro_no(v->adjacencias_saida); n != NULL; n = proximo_no(n)){
adjacencia viz = conteudo(n);
Agedge_t *ae = agedge(ag, nodes[v->id], nodes[viz->v_destino->id], NULL, TRUE);
if(g->ponderado){
sprintf(peso_s, "%ld", viz->peso);
agxset(ae, peso, peso_s);
}
}
}
free(nodes);
agwrite(ag, output);
agclose(ag);
agfree(ag, NULL);
return g;
}
/**
* Render a tree to tree graph image via graphviz (dot)
*/
int r3_tree_render_file(const node * tree, const char * format, char * filename)
{
Agraph_t *g;
/* set up a graphviz context - but only once even for multiple graphs */
static GVC_t *gvc;
if (!gvc) {
gvc = gvContext();
}
/* Create a simple digraph */
g = agopen("g", Agdirected, 0);
// create self node
Agnode_t *ag_root = agnode(g, "{root}", 1);
r3_tree_build_ag_nodes(g, ag_root, tree, 0);
gvLayout(gvc, g, "dot");
gvRenderFilename(gvc, g, format, filename);
gvFreeLayout(gvc, g);
agclose(g);
return 0;
}
static void begin_graph(char *name)
{
Agraph_t *g;
g = AG.parsed_g = agopen(name,Agraph_type);
push_subg(g);
In_decl = TRUE;
}
static graph_t *create_test_graph(void)
{
#define NUMNODES 5
Agnode_t *node[NUMNODES];
Agraph_t *g;
int j, k;
char name[10];
/* Create a new graph */
g = agopen("new_graph", AGDIGRAPH);
/* Add nodes */
for (j = 0; j < NUMNODES; j++) {
sprintf(name, "%d", j);
node[j] = agnode(g, name);
}
/* Connect nodes */
for (j = 0; j < NUMNODES; j++) {
for (k = j + 1; k < NUMNODES; k++) {
agedge(g, node[j], node[k]);
}
}
return g;
}
static graph_t *
mkConstraintG (graph_t * g, Dt_t * list, intersectfn intersect, distfn dist)
{
graph_t *vg;
graph_t *cg = agopen ("cg", Agstrictdirected, ((Agdisc_t *) 0));
mapGraphs (vg, cg, dist);
}
/* GVLayout */
GVLayout::GVLayout()
{
this->gvc = gvContext();
#ifdef USE_LIBGRAPH_NOT_LIBCGRAPH
this->gvgraph = agopen((char*)"g", AGDIGRAPH);
#else
this->gvgraph = agopen((char*)"g", Agdirected, NULL);
#endif
agsafeset(this->gvgraph, (char*)"splines", (char*)"true", (char*)"");
agsafeset(this->gvgraph, (char*)"overlap", (char*)"false", (char*)"");
agsafeset(this->gvgraph, (char*)"rankdir", (char*)"LR", (char*)"");
agsafeset(this->gvgraph, (char*)"nodesep", (char*)"2.0", (char*)"");
agsafeset(this->gvgraph, (char*)"labelloc", (char*)"t", (char*)"");
}
QGVScene::QGVScene(const QString &name, QObject *parent) : QGraphicsScene(parent),
_label (NULL)
{
_context = new QGVGvcPrivate(gvContext());
_graph = new QGVGraphPrivate(agopen(name.toLocal8Bit().data(), Agdirected, NULL));
//setGraphAttribute("fontname", QFont().family());
}
void ImplemGraphviz::drawGraph()
{
GVC_t *gvc=gvContext();
G=agopen("G",AGRAPH); //Ici pour modifier afin que le graphe soit orienté : AGRAPH -> AGDIGRAPH
if(graphe->isColore())
{
GrapheColore* graph=(GrapheColore*) graphe->getGraph();
creerListeNodes(graph);
creerListeEdges(graph);
}
else
{
Graphe* graph=(Graphe*) graphe->getGraph();
creerListeNodes(graph);
creerListeEdges(graph);
}
gvLayout(gvc,G,"dot");
gvRenderFilename(gvc,G,"svg",lienSVG.toStdString().c_str());
load(lienSVG);
adjustSize();
parentWidget()->adjustSize();
}
static int process(Agraph_t * g, int gcnt)
{
Agnode_t *n;
bcstate state;
Agraph_t *blk;
Agraph_t *tree;
int bcnt;
aginit(g, AGNODE, "info", sizeof(Agnodeinfo_t), TRUE);
aginit(g, AGEDGE, "info", sizeof(Agedgeinfo_t), TRUE);
aginit(g, AGRAPH, "info", sizeof(Agraphinfo_t), TRUE);
state.count = 0;
state.nComp = 0;
state.stk = 0;
state.blks = 0;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (N(n) == 0)
dfs(g, n, &state, 0);
}
for (blk = state.blks; blk; blk = NEXTBLK(blk)) {
nodeInduce(blk, g);
}
if (external) {
bcnt = 0;
for (blk = state.blks; blk; blk = NEXTBLK(blk)) {
gwrite(blk, gcnt, bcnt++);
}
} else
gwrite(g, gcnt, 0);
if (doTree) {
tree = agopen("blkcut_tree", Agstrictundirected, 0);
for (blk = state.blks; blk; blk = NEXTBLK(blk))
addCutPts(tree, blk);
gwrite(tree, gcnt, -1);
agclose(tree);
}
if (verbose) {
int cuts = 0;
bcnt = 0;
for (blk = state.blks; blk; blk = NEXTBLK(blk))
bcnt++;
for (n = agfstnode(g); n; n = agnxtnode(g, n))
if (Cut(n))
cuts++;
fprintf(stderr, "%s: %d blocks %d cutpoints\n", agnameof(g), bcnt,
cuts);
}
if (state.blks && NEXTBLK(state.blks))
return 1; /* >= 2 blocks */
else
return 0;
}
/* sizeArray:
* Set column and row sizes. Optimize for minimum width and
* height. Where there is slack, try to distribute evenly.
* We do this by encoding cells as edges with min length is
* a dag on a chain. We then run network simplex, using
* LR_balance.
*/
void sizeArray(htmltbl_t * tbl)
{
graph_t *rowg;
graph_t *colg;
/* Do the 1D cases by hand */
if ((tbl->rc == 1) || (tbl->cc == 1)) {
sizeLinearArray(tbl);
return;
}
tbl->heights = N_NEW(tbl->rc + 1, int);
tbl->widths = N_NEW(tbl->cc + 1, int);
rowg = agopen("rowg", AGDIGRAPH);
colg = agopen("colg", AGDIGRAPH);
makeGraphs(tbl, rowg, colg);
rank(rowg, 2, INT_MAX);
rank(colg, 2, INT_MAX);
setSizes(tbl, rowg, colg);
closeGraphs(rowg, colg);
}
int main(int argc, char** argv)
{
Agraph_t *g;
Agnode_t *n,*m;
Agedge_t *e;
Agsym_t *a;
GVC_t *gvc;
/* set up renderer context */
gvc = gvContext();
/* Accept -T and -o options like dot.
* Input files are ignored in this demo. */
dotneato_initialize(gvc, argc,argv);
/* Create a simple digraph */
g = agopen("g",AGDIGRAPH);
n = agnode(g,"n");
m = agnode(g,"m");
e = agedge(g,n,m);
/* Set an attribute - in this case one that affects the visible rendering */
if (!(a = agfindattr(g->proto->n, "color")))
a = agnodeattr(g, "color", "");
agxset(n, a->index, "red");
/* bind graph to GV context - currently must be done before layout */
gvBindContext(gvc,g);
/* Compute a layout */
neato_layout(g);
/* twopi_layout(g); */
/* dot_layout(g); */
/* Write the graph according to -T and -o options */
dotneato_write(gvc);
/* Clean out layout data */
/* neato_cleanup(g); */
/* twopi_cleanup(g); */
/* dot_cleanup(g); */
/* Free graph structures */
agclose(g);
/* Clean up output file and errors */
dotneato_terminate(gvc);
return 1;
}
void QGVScene::clear()
{
_nodes.clear();
_edges.clear();
_subGraphs.clear();
textlabel_t* label = GD_label(_graph->graph());
char* name = new char[strlen(label->text)+1];
strncpy(name, label->text, strlen(label->text)+1);
agclose (_graph->graph());
_graph->setGraph(agopen(name, Agdirected, NULL));
delete[] name;
QGraphicsScene::clear();
_label = NULL;
}
/*----------------------------------------------------------------------------
* initialize the internal graphviz structure.
*/
static void
cls_inherit_graph_init (AnjutaClassInheritance *plugin, gchar* graph_label)
{
Agsym_t *sym;
gchar dpi_text[16];
snprintf (dpi_text, 16, "%d", INCH_TO_PIXELS_CONVERSION_FACTOR);
aginit ();
plugin->graph = agopen (graph_label, AGDIGRAPH);
plugin->gvc = gvContext();
if (!(sym = agfindattr(plugin->graph->proto->n, "dpi")))
sym = agraphattr(plugin->graph, "dpi", dpi_text);
agxset(plugin->graph, sym->index, dpi_text);
}
static void begin_graph(char *name)
{
Agraph_t *g;
char buf[SMALLBUF];
if (!name) {
anonname(buf);
name = buf;
}
g = AG.parsed_g = agopen(name,Agraph_type);
Current_class = TAG_GRAPH;
headsubsym = tailsubsym = NULL;
push_subg(g);
In_decl = TRUE;
}
static void initproto(void)
{
Agsym_t *a;
Agraph_t *g;
g = AG.proto_g = agopen("ProtoGraph", AGRAPH);
a = dcl_attr(g->proto->e, KEY_ID, "");
if (a->index != KEYX)
abort();
a = dcl_attr(g->proto->e, TAIL_ID, "");
if (a->index != TAILX)
abort();
a->printed = FALSE;
a = dcl_attr(g->proto->e, HEAD_ID, "");
if (a->index != HEADX)
abort();
a->printed = FALSE;
}
/* mkMCGraph:
* Clone original graph. We only need the nodes, edges and clusters.
* Copy
*/
Agraph_t*
mkMCGraph (Agraph_t* g)
{
Agnode_t* t;
Agnode_t* newt;
Agnode_t* newh;
Agedge_t* e;
Agedge_t* newe;
Agraph_t* sg;
edgepair_t* data;
edgepair_t* ep;
Agraph_t* newg = agopen (agnameof(g), g->desc, 0);
Dt_t* emap = dtopen (&edgepair, Dtoset);;
data = N_NEW(agnedges(g), edgepair_t);
ep = data;
for (t = agfstnode(g); t; t = agnxtnode(g, t)) {
newt = mkMCNode (newg, STDNODE, agnameof(t));
assert(newt);
MND_orig(newt) = t;
MND_rank(newt) = ND_rank(t);
}
for (t = agfstnode(g); t; t = agnxtnode(g, t)) {
newt = agnode (newg, agnameof(t), 0);
for (e = agfstout(g, t); e; e = agnxtout(g, e)) {
newh = agnode (newg, agnameof(aghead(e)), 0);
assert(newh);
newe = mkMCEdge (newg, newt, newh, agnameof (e), NORMAL, e);
assert(newe);
ep->key = e;
ep->val = newe;
dtinsert (emap, ep++);
}
}
for (sg = agfstsubg(g); sg; sg = agnxtsubg(sg)) {
cloneSubg(newg, sg, emap);
}
dtclose (emap);
free (data);
return newg;
}
int main(int argc, char **argv)
{
Agraph_t *g;
Agnode_t *n, *m;
Agedge_t *e;
Agsym_t *a;
#ifdef NO_LAYOUT_OR_RENDERING
aginit();
#else
/* set up a graphviz context - but only once even for multiple graphs */
static GVC_t *gvc;
if (!gvc)
gvc = gvContext();
#endif
/* Create a simple digraph */
g = agopen("g", AGDIGRAPH);
n = agnode(g, "n");
m = agnode(g, "m");
e = agedge(g, n, m);
/* Set an attribute - in this case one that affects the visible rendering */
agsafeset(n, "color", "red", "");
#ifdef NO_LAYOUT_OR_RENDERING
/* Just write the graph without layout */
agwrite(g, stdout);
#else
/* Use the directed graph layout engine */
gvLayout(gvc, g, "dot");
/* Output in .dot format */
gvRender(gvc, g, "dot", stdout);
gvFreeLayout(gvc, g);
#endif
agclose(g);
return 0;
}
void EuclideanNetwork::show(std::string filename, const char* filetype) {
GVC_t *gvc;
Agraph_t *g;
std::stringstream sStream;
std::vector<Agnode_t *> vNodes;
std::vector<Agedge_t *> vEdges;
int i = 0;
if (v < 1) return;
gvc = gvContext();
g = agopen("g", Agundirected, 0);
while (i < v) {
sStream.str("");
sStream << i;
vNodes.push_back(agnode(g, sStream.str().c_str(), 1));
sStream.str("");
sStream << x[i]*7 << "," << y[i]*7 << "!";
agsafeset(vNodes[vNodes.size()-1], "height", "0.4", "");
agsafeset(vNodes[vNodes.size()-1], "width", "0.4", "");
agsafeset(vNodes[vNodes.size()-1], "fixedsize", "true", "");
agsafeset(vNodes[vNodes.size()-1], "pos", sStream.str().c_str(), "");
i++;
}
for (std::set<Edge>::iterator x = e.begin(); x != e.end(); ++x) {
sStream.str("");
sStream << ((*x).wage * scale);
vEdges.push_back(agedge(g, vNodes[(*x).v1], vNodes[(*x).v2], sStream.str().c_str(), 1));
}
gvLayout(gvc, g, "fdp");
gvRenderFilename(gvc, g, filetype, filename.c_str());
gvFreeLayout(gvc, g);
agclose(g);
gvFreeContext(gvc);
return;
}
static graph_t *
mkNConstraintG (graph_t * g, Dt_t * list, intersectfn intersect, distfn dist)
{
nitem *p;
nitem *nxp;
edge_t *e;
graph_t *cg = agopen ("cg", Agstrictdirected, ((Agdisc_t *) 0));
for (p = (nitem *) dtflatten (list); p;
p = (nitem *) (((Dtlink_t *) ((Dtlink_t *) p))->right))
{
for (nxp = (nitem *) (((Dtlink_t *) ((Dtlink_t *) p))->right); nxp;
nxp = (nitem *) (((Dtlink_t *) ((Dtlink_t *) nxp))->right))
{
if (intersect (p, nxp))
{
e = agedge (cg, p->cnode, nxp->cnode, ((void *) 0), 1);
}
}} for (p = (nitem *) dtflatten (list); p;
p = (nitem *) (((Dtlink_t *) ((Dtlink_t *) p))->right))
{
}
}
void graph2png(const agent *a, const agent *n, const contr c, const contr r, const contr d, const char* filename) {
const agent *p = n + N + 1;
agent m = n[N];
GVC_t *gvc = gvContext();
Agraph_t* g = agopen("test", Agstrictundirected, 0);
agsafeset(g, "overlap", "false", "");
Agnode_t* nodes[N];
do { nodes[*p] = agnode(g, names[*p], 1); p++; }
while (--m);
for (agent i = 1; i < E + 1; i++) if (!ISSET(c, i) && !ISSET(d, i)) {
Agedge_t *e = agedge(g, nodes[X(a, i)], nodes[Y(a, i)], "", 1);
if (ISSET(r, i)) agsafeset(e, "color", "red", "");
}
gvLayout(gvc, g, "neato");
gvRenderFilename(gvc, g, "png", filename);
gvFreeLayout(gvc, g);
agclose(g);
gvFreeContext(gvc);
}
static void cluster_contents(Agraph_t *ug)
{
Agraph_t *mg;
char *name;
assert(is_a_cluster(ug));
assert(GD_model(ug) == 0);
name = malloc(strlen(ug->name)+10);
sprintf(name,"model_%s",ug->name);
GD_model(ug) = mg = agopen(name,AGDIGRAPHSTRICT);
free(name);
/* install internal nodes */
for (n = agfstnode(ug); n; n = agnxtnode(ug,n)) {
if (ND_cluster(n) == ug) model_intnode(mg,n);
}
/* install cluster skeletons */
rec_model_subclusts(mg,ug);
/* install external edge endpoints */
root = GD_layoutroot(ug);
for (n = agfstnode(ug); n; n = agnxtnode(ug,n)) {
for (e = agfstout(root,n); e; e = agnxtout(root,e)) {
if (!agcontains(ug,e->tail))
model_extnode(mg,e->tail);
if (!agcontains(ug,e->head))
model_extnode(mg,e->head);
}
}
/* install edges */
for (n = agfstnode(ug); n; n = agnxtnode(ug,n))
for (e = agfstout(root,n); e; e = agnxtout(root,e))
model_edge(mg,e); /* amazing if this is all it takes */
}
static void
process(Agraph_t* G)
{
Agnode_t* n;
Agraph_t* map;
int nc = 0;
float nontree_frac;
int Maxdegree;
Stack stack;
sccstate state;
aginit(G,AGRAPH,"scc_graph",sizeof(Agraphinfo_t),TRUE);
aginit(G,AGNODE,"scc_node",sizeof(Agnodeinfo_t),TRUE);
state.Comp = state.ID = 0;
state.N_nodes_in_nontriv_SCC = 0;
if (Verbose)
nc = countComponents(G,&Maxdegree,&nontree_frac);
initStack(&stack, agnnodes(G) + 1);
map = agopen("scc_map",Agdirected,(Agdisc_t *)0);
for (n = agfstnode(G); n; n = agnxtnode(n))
if (getval(n) == 0) visit(n,map,&stack,&state);
freeStack(&stack);
if (!Silent) agwrite(map,stdout);
agclose(map);
if (Verbose)
fprintf(stderr,"%d %d %d %d %.4f %d %.4f\n",
agnnodes(G), agnedges(G), nc, state.Comp,
state.N_nodes_in_nontriv_SCC / (double) agnnodes(G), Maxdegree,
nontree_frac);
else
fprintf(stderr,"%d nodes, %d edges, %d strong components\n",
agnnodes(G), agnedges(G), state.Comp);
}
int main(int argc, char **argv)
{
Agraph_t *g;
Agnode_t *n, *m;
Agedge_t *e;
GVC_t *gvc;
/* set up a graphviz context */
gvc = gvContext();
/* parse command line args - minimally argv[0] sets layout engine */
gvParseArgs(gvc, argc, argv);
/* Create a simple digraph */
g = agopen("g", AGDIGRAPH);
n = agnode(g, "n");
m = agnode(g, "m");
e = agedge(g, n, m);
/* Set an attribute - in this case one that affects the visible rendering */
agsafeset(n, "color", "red", "");
/* Compute a layout using layout engine from command line args */
gvLayoutJobs(gvc, g);
/* Write the graph according to -T and -o options */
gvRenderJobs(gvc, g);
/* Free layout data */
gvFreeLayout(gvc, g);
/* Free graph structures */
agclose(g);
/* close output file, free context, and return number of errors */
return (gvFreeContext(gvc));
}
static int visit(Agnode_t * n, Agraph_t * map, Stack * sp, sccstate * st)
{
unsigned int m, min;
Agnode_t *t;
Agraph_t *subg;
Agedge_t *e;
min = ++(st->ID);
setval(n, min);
push(sp, n);
#ifdef USE_CGRAPH
for (e = agfstout(n->root, n); e; e = agnxtout(n->root, e)) {
#else
for (e = agfstout(n); e; e = agnxtout(e)) {
#endif
t = aghead(e);
if (getval(t) == 0)
m = visit(t, map, sp, st);
else
m = getval(t);
if (m < min)
min = m;
}
if (getval(n) == min) {
if (!wantDegenerateComp && (top(sp) == n)) {
setval(n, INF);
pop(sp);
} else {
char name[32];
Agraph_t *G = agraphof(n);;
sprintf(name, "cluster_%d", (st->Comp)++);
subg = agsubg(G, name, TRUE);
agbindrec(subg, "scc_graph", sizeof(Agraphinfo_t), TRUE);
setrep(subg, agnode(map, name, TRUE));
do {
t = pop(sp);
agsubnode(subg, t, TRUE);
setval(t, INF);
setscc(t, subg);
st->N_nodes_in_nontriv_SCC++;
} while (t != n);
#ifdef USE_CGRAPH
nodeInduce(subg, map);
#else
nodeInduce(subg);
#endif
if (!Silent)
agwrite(subg, stdout);
}
}
return min;
}
static int label(Agnode_t * n, int nodecnt, int *edgecnt)
{
Agedge_t *e;
setval(n, 1);
nodecnt++;
#ifdef USE_CGRAPH
for (e = agfstedge(n->root, n); e; e = agnxtedge(n->root, e, n)) {
#else
for (e = agfstedge(n); e; e = agnxtedge(e, n)) {
#endif
(*edgecnt) += 1;
if (e->node == n)
e = agopp(e);
if (!getval(e->node))
nodecnt = label(e->node, nodecnt, edgecnt);
}
return nodecnt;
}
static int
countComponents(Agraph_t * g, int *max_degree, float *nontree_frac)
{
int nc = 0;
int sum_edges = 0;
int sum_nontree = 0;
int deg;
int n_edges;
int n_nodes;
Agnode_t *n;
#ifdef USE_CGRAPH
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
#else
for (n = agfstnode(g); n; n = agnxtnode(n)) {
#endif
if (!getval(n)) {
nc++;
n_edges = 0;
n_nodes = label(n, 0, &n_edges);
sum_edges += n_edges;
sum_nontree += (n_edges - n_nodes + 1);
}
}
if (max_degree) {
int maxd = 0;
#ifdef USE_CGRAPH
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
deg = agdegree(g, n, TRUE, TRUE);
#else
for (n = agfstnode(g); n; n = agnxtnode(n)) {
deg = agdegree(n, TRUE, TRUE);
#endif
if (maxd < deg)
maxd = deg;
setval(n, 0);
}
*max_degree = maxd;
}
if (nontree_frac) {
if (sum_edges > 0)
*nontree_frac = (float) sum_nontree / (float) sum_edges;
else
*nontree_frac = 0.0;
}
return nc;
}
static void process(Agraph_t * G)
{
Agnode_t *n;
Agraph_t *map;
int nc = 0;
float nontree_frac = 0;
int Maxdegree = 0;
Stack stack;
sccstate state;
aginit(G, AGRAPH, "scc_graph", sizeof(Agraphinfo_t), TRUE);
aginit(G, AGNODE, "scc_node", sizeof(Agnodeinfo_t), TRUE);
state.Comp = state.ID = 0;
state.N_nodes_in_nontriv_SCC = 0;
if (Verbose)
nc = countComponents(G, &Maxdegree, &nontree_frac);
initStack(&stack, agnnodes(G) + 1);
map = agopen("scc_map", Agdirected, (Agdisc_t *) 0);
#ifdef USE_CGRAPH
for (n = agfstnode(G); n; n = agnxtnode(G, n))
#else
for (n = agfstnode(G); n; n = agnxtnode(n))
#endif
if (getval(n) == 0)
visit(n, map, &stack, &state);
freeStack(&stack);
if (!Silent)
agwrite(map, stdout);
agclose(map);
if (Verbose)
fprintf(stderr, "%d %d %d %d %.4f %d %.4f\n",
agnnodes(G), agnedges(G), nc, state.Comp,
state.N_nodes_in_nontriv_SCC / (double) agnnodes(G),
Maxdegree, nontree_frac);
else
fprintf(stderr, "%d nodes, %d edges, %d strong components\n",
agnnodes(G), agnedges(G), state.Comp);
}
static char *useString = "Usage: %s [-sdv?] <files>\n\
-s - silent\n\
-d - allow degenerate components\n\
-v - verbose\n\
-? - print usage\n\
If no files are specified, stdin is used\n";
static void usage(int v)
{
printf(useString, CmdName);
exit(v);
}
int render_graph(rendering_ctx_t *rctx,
const char* filename,
const char* format)
{
Agraph_t *g;
Agnode_t *n;
Agnode_t *d;
Agedge_t *e;
GVC_t *gvc;
rnsGraph_t *rnsGraph;
char w[32];
FILE *fp;
fp = fopen(filename, "w+");
gvc = gvContext();
rnsGraph = rctx->graph;
if (rctx->directed){
g = agopen("g", Agstrictdirected, 0);
}else{
g = agopen("g", Agstrictundirected, 0);
}
size_t i, j;
for (i=0; i<rnsGraph->size; i++){
if ( !rnsGraph->repos[i]) {
continue;
}
n = agnode(g, rnsGraph->repos[i]->id, 1);
for (j=0; j<rnsGraph->repos[i]->maxLinks; j++){
if (!rnsGraph->repos[i]->links[j]){
continue;
}
d = agnode(g, rnsGraph->repos[i]->links[j]->repo->id, 1);
e = agedge(g, n, d, 0, 1);
snprintf(w, sizeof(w), "%1.3g", (double) cost(rnsGraph->repos[i],
rnsGraph->repos[i]->links[j]));
agsafeset(e, "label", w, "");
if (rnsGraph->repos[i]->links[j]->is_path){
agsafeset(e, "color", "red", "");
}
}
}
// char *args[] = {
// "sfdp",
// "-x",
// "-Tpng",
// "-Goverlap=scale",
// "-GK=5.0",
// "-ooutput/random.png"
// };
// gvParseArgs (gvc, sizeof(args)/sizeof(char*), args);
// gvLayoutJobs(gvc, g);
// gvRenderJobs(gvc, g);
gvLayout(gvc, g, "dot");
gvRender(gvc, g, format, fp);
gvFreeLayout(gvc, g);
agclose(g);
fclose(fp);
return (gvFreeContext(gvc));
}
static inline Agraph_t* _agopen(QString name, int kind){
setlocale(LC_NUMERIC,"en_US.UTF-8");
return agopen(const_cast<char *>(qPrintable(name)),kind);
}
int ggen_write_graph(igraph_t *g, FILE *output)
{
Agraph_t *cg;
Agnode_t *f,*t;
Agedge_t *edge;
igraph_vector_ptr_t vertices;
igraph_eit_t eit;
int err;
unsigned long i,j;
unsigned long vcount = igraph_vcount(g);
igraph_integer_t from,to;
char name[GGEN_DEFAULT_NAME_SIZE];
char *str = NULL;
igraph_strvector_t gnames,vnames,enames;
igraph_vector_t gtypes,vtypes,etypes;
Agsym_t *attr;
/* see warning below */
igraph_error_handler_t *error_handler;
err = igraph_vector_ptr_init(&vertices,vcount);
if(err) return 1;
/* WARNING: this should be changed if igraph-0.6 gets
* stable.
* We need to ignore some igraph_cattribute errors
* because we try to retrieve special attributes (ggen specifics).
* igraph version 0.6 include a cattribute_has_attr that should be
* used instead of ignoring errors.
*/
error_handler = igraph_set_error_handler(igraph_error_handler_ignore);
/* open graph
* its name is saved in __ggen_graph_name if it exists
*/
str =(char *) GAS(g,GGEN_GRAPH_NAME_ATTR);
if(!str)
cg = agopen(GGEN_DEFAULT_GRAPH_NAME,Agdirected,NULL);
else
cg = agopen(str,Agdirected,NULL);
if(!cg)
{
err = 1;
goto d_v;
}
/* save a pointer to each vertex */
for(i = 0; i < vcount; i++)
{
/* find a vertex name */
str = vid2vname_unsafe(name,g,i);
if(!str)
f = agnode(cg,name,1);
else
f = agnode(cg,str,1);
VECTOR(vertices)[i] = (void *)f;
}
/* We have finished with dangerous attributes accesses */
igraph_set_error_handler(error_handler);
/* now loop through edges in the igraph */
err = igraph_eit_create(g,igraph_ess_all(IGRAPH_EDGEORDER_ID),&eit);
if(err) goto c_ag;
for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit))
{
err = igraph_edge(g,IGRAPH_EIT_GET(eit),&from,&to);
if(err) goto d_eit;
f = (Agnode_t *) VECTOR(vertices)[(unsigned long)from];
t = (Agnode_t *) VECTOR(vertices)[(unsigned long)to];
agedge(cg,f,t,NULL,1);
}
/* find all properties */
igraph_strvector_init(&gnames,1);
igraph_strvector_init(&vnames,vcount);
igraph_strvector_init(&enames,igraph_ecount(g));
igraph_vector_init(>ypes,1);
igraph_vector_init(&vtypes,vcount);
igraph_vector_init(&etypes,igraph_ecount(g));
err = igraph_cattribute_list(g,&gnames,>ypes,&vnames,&vtypes,&enames,&etypes);
if(err) goto d_eit;
/* add graph properties */
for(i = 0; i < igraph_strvector_size(&gnames); i++)
{
if(strcmp(GGEN_GRAPH_NAME_ATTR,STR(gnames,i)))
{
if(VECTOR(gtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f",
(double)GAN(g,STR(gnames,i)));
agattr(cg,AGRAPH,(char *)STR(gnames,i),name);
}
else
agattr(cg,AGRAPH,(char *)STR(gnames,i),
(char *)GAS(g,STR(gnames,i)));
}
}
/* add vertex properties */
for(i = 0; i < igraph_strvector_size(&vnames); i++)
{
if(strcmp(GGEN_VERTEX_NAME_ATTR,STR(vnames,i)))
{
/* creates the attribute but we still need to set it for each vertex */
attr = agattr(cg,AGNODE,(char *)STR(vnames,i),GGEN_CGRAPH_DEFAULT_VALUE);
for(j = 0; j < vcount; j++)
{
f = (Agnode_t *) VECTOR(vertices)[j];
if(VECTOR(vtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f",
(double)VAN(g,STR(vnames,i),j));
agxset(f,attr,name);
}
else
agxset(f,attr,(char *)VAS(g,STR(vnames,i),j));
}
}
}
/* add edges properties */
for(i = 0; i < igraph_strvector_size(&enames); i++)
{
/* creates the attribute but we still need to set it for each edge */
attr = agattr(cg,AGEDGE,(char *)STR(enames,i),GGEN_CGRAPH_DEFAULT_VALUE);
for(j = 0; j < igraph_ecount(g); j++)
{
igraph_edge(g,j,&from,&to);
f = (Agnode_t *) VECTOR(vertices)[(unsigned long)from];
t = (Agnode_t *) VECTOR(vertices)[(unsigned long)to];
edge = agedge(cg,f,t,NULL,0);
if(VECTOR(etypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) {
snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f",
(double)EAN(g,STR(enames,i),j));
agxset(edge,attr,name);
}
else
agxset(edge,attr,(char *)EAS(g,STR(enames,i),j));
}
}
/* write the graph */
err = agwrite(cg,(void *)output);
d_eit:
igraph_eit_destroy(&eit);
c_ag:
agclose(cg);
d_v:
igraph_vector_ptr_destroy(&vertices);
return err;
}
