__attribute__((used)) char* vizRenderFromString(char *string, char *format) {
GVC_t *context = gvContext();
gvAddLibrary(context, &gvplugin_core_LTX_library);
gvAddLibrary(context, &gvplugin_dot_layout_LTX_library);
gvAddLibrary(context, &gvplugin_neato_layout_LTX_library);
Agraph_t *graph = agmemread(string);
gvLayout(context, graph, "dot"); //NOTE: customizable via the 'layout' graph attribute
char *result;
unsigned int length;
gvRenderData(context, graph, format, &result, &length);
gvFreeLayout(context, graph);
agclose(graph);
gvFinalize(context);
gvFreeContext(context);
return result;
}
/* undoClusterEdges:
* Replace cluster nodes with originals. Make sure original has
* no attributes. Replace original edges. Delete cluster nodes,
* which will also delete cluster edges.
*/
void undoClusterEdges(graph_t * g)
{
node_t *n;
node_t *nextn;
edge_t *e;
graph_t *clg;
clg = agsubg(g, "__clusternodes",1);
agbindrec(clg, "Agraphinfo_t", sizeof(Agraphinfo_t), TRUE);
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
undoCompound(e, clg);
}
}
for (n = agfstnode(clg); n; n = nextn) {
nextn = agnxtnode(clg, n);
gv_cleanup_node(n);
agdelete(g, n);
}
agclose(clg);
}
int run_gvpr(Agraph_t * srcGraph, int argc, char *argv[])
{
int i, rv = 1;
gvpropts opts;
Agraph_t *gs[2];
static int count;
char buf[SMALLBUF];
gs[0] = srcGraph;
gs[1] = 0;
memset (&opts, 0, sizeof(opts));
opts.ingraphs = gs;
opts.out = outfn;
opts.err = outfn;
opts.flags = GV_USE_OUTGRAPH;
rv = gvpr(argc, argv, &opts);
if (rv) { /* error */
fprintf(stderr, "Error in gvpr\n");
} else if (opts.n_outgraphs)
{
refreshViewport(0);
sprintf(buf, "<%d>", ++count);
if (opts.outgraphs[0] != view->g[view->activeGraph])
add_graph_to_viewport(opts.outgraphs[0], buf);
if (opts.n_outgraphs > 1)
fprintf(stderr, "Warning: multiple output graphs-discarded\n");
for (i = 1; i < opts.n_outgraphs; i++) {
agclose(opts.outgraphs[i]);
}
} else
{
/* set_refresh(view,argv[1]); */
updateRecord (srcGraph);
update_graph_from_settings(srcGraph);
// update_topview(srcGraph, view->Topview, 0);
}
return rv;
}
int main(int argc, char **argv)
{
Agraph_t *G;
Agraph_t *prev = 0;
int rv;
ingraph_state ig;
rv = 0;
initargs(argc, argv);
newIngraph(&ig, Files, gread);
while ((G = nextGraph(&ig))) {
if (prev) {
id = 0;
agclose(prev);
}
prev = G;
gv_to_gml(G, outFile);
fflush(outFile);
}
exit(rv);
}
void Network::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));
agsafeset(vNodes[vNodes.size()-1], "height", "0.4", "");
agsafeset(vNodes[vNodes.size()-1], "width", "0.4", "");
agsafeset(vNodes[vNodes.size()-1], "fixedsize", "true", "");
}
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));
agsafeset(vEdges[vEdges.size()-1], "len", sStream.str().c_str(), "");
}
gvLayout(gvc, g, "fdp");
gvRenderFilename(gvc, g, filetype, filename.c_str());
gvFreeLayout(gvc, g);
agclose(g);
gvFreeContext(gvc);
return;
};
main(int argc, char **argv)
{
Agraph_t *g, *prev;
int dostat;
if (argc > 1)
dostat = atoi(argv[1]);
else
dostat = 0;
prev = agopen("some_name", Agdirected, NIL(Agdisc_t *));
agcallbacks(prev, FALSE);
agpushdisc(prev, &mydisc, NIL(void *));
while (g = agconcat(prev, stdin, NIL(Agdisc_t *))) {
/*do_it(g, dostat); */
}
/*agwrite(prev,stdout); */
fprintf(stderr, "ready to go, computer fans\n");
agcallbacks(prev, TRUE);
agclose(prev);
return 1;
}
/* lockGraph:
* Set lock so that graph g will not be deleted.
* g must be a root graph.
* If v > 0, set lock
* If v = 0, unset lock and delete graph is necessary.
* If v < 0, no op
* Always return previous lock state.
* Return -1 on error.
*/
int lockGraph(Agraph_t * g, int v)
{
gdata *data;
int oldv;
if (g != agroot(g)) {
error(ERROR_WARNING,
"Graph argument to lock() is not a root graph");
return -1;
}
data = gData(g);
oldv = data->lock & 1;
if (v > 0)
data->lock |= 1;
else if ((v == 0) && oldv) {
if (data->lock & 2)
agclose(g);
else
data->lock = 0;
}
return oldv;
}
int main (int argc, char* argv[])
{
graph_t *g;
graph_t *sg;
FILE *fp;
graph_t** cc;
int i, ncc;
GVC_t *gvc;
gvc = gvContext();
if (argc > 1)
fp = fopen(argv[1], "r");
else
fp = stdin;
g = agread(fp, 0);
cc = ccomps(g, &ncc, (char*)0);
for (i = 0; i < ncc; i++) {
sg = cc[i];
nodeInduce (sg);
gvLayout(gvc, sg, "neato");
}
pack_graph (ncc, cc, g, 0);
gvRender(gvc, g, "ps", stdout);
for (i = 0; i < ncc; i++) {
sg = cc[i];
gvFreeLayout(gvc, sg);
agdelete(g, sg);
}
agclose(g);
return (gvFreeContext(gvc));
}
int
main (int argc, char* argv[])
{
Agraph_t* g;
ingraph_state ig;
int rv = 0;
init (argc, argv);
newIngraph (&ig, Files, agread);
while ((g = nextGraph(&ig)) != 0) {
fname = fileName(&ig);
if (verbose)
fprintf (stderr, "Process graph %s in file %s\n", g->name, fname);
rv |= eval (g, 1);
agclose (g);
}
if (n_graphs > 1)
wcp (tot_nodes, tot_edges, tot_cc, tot_cl, "total", 0);
return rv;
}
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
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));
}
void*
AI_alert_correlation_thread ( void *arg )
{
int i;
struct stat st;
char corr_dot_file[4096] = { 0 };
#ifdef HAVE_LIBGVC
char corr_ps_file [4096] = { 0 };
#endif
double avg_correlation = 0.0,
std_deviation = 0.0,
corr_threshold = 0.0,
kb_correlation = 0.0,
bayesian_correlation = 0.0,
neural_correlation = 0.0;
size_t n_correlations = 0,
n_corr_functions = 0,
n_corr_weights = 0;
FILE *fp = NULL;
AI_alert_correlation_key corr_key;
AI_alert_correlation *corr = NULL;
AI_alert_type_pair_key pair_key;
AI_alert_type_pair *pair = NULL,
*unpair = NULL;
AI_snort_alert *alert_iterator = NULL,
*alert_iterator2 = NULL;
pthread_t manual_corr_thread;
#ifdef HAVE_LIBGVC
char corr_png_file[4096] = { 0 };
GVC_t *gvc = NULL;
graph_t *g = NULL;
#endif
double (**corr_functions)( const AI_snort_alert*, const AI_snort_alert* ) = NULL;
double (**corr_weights)() = NULL;
#ifdef HAVE_LIBPYTHON2_6
PyObject *pyA = NULL,
*pyB = NULL;
PyObject *pArgs = NULL,
*pRet = NULL;
PyObject **py_corr_functions = NULL;
PyObject **py_weight_functions = NULL;
size_t n_py_corr_functions = 0;
size_t n_py_weight_functions = 0;
double py_value = 0.0,
py_weight = 0.0;
py_corr_functions = AI_get_py_functions ( &n_py_corr_functions );
py_weight_functions = AI_get_py_weights ( &n_py_weight_functions );
#endif
corr_functions = AI_get_corr_functions ( &n_corr_functions );
corr_weights = AI_get_corr_weights ( &n_corr_weights );
pthread_mutex_init ( &mutex, NULL );
/* Start the thread for parsing manual correlations from XML */
if ( pthread_create ( &manual_corr_thread, NULL, AI_manual_correlations_parsing_thread, NULL ) != 0 )
{
AI_fatal_err ( "Failed to create the manual correlations parsing thread", __FILE__, __LINE__ );
}
while ( 1 )
{
sleep ( config->correlationGraphInterval );
if ( stat ( config->corr_rules_dir, &st ) < 0 )
{
_dpd.errMsg ( "AIPreproc: Correlation rules directory '%s' not found, the correlation thread won't be active\n",
config->corr_rules_dir );
pthread_exit (( void* ) 0 );
return ( void* ) 0;
}
/* Set the lock flag to true, and keep it this way until I've done with correlating alerts */
pthread_mutex_lock ( &mutex );
if ( alerts )
{
AI_free_alerts ( alerts );
alerts = NULL;
}
if ( !( alerts = AI_get_clustered_alerts() ))
{
pthread_mutex_unlock ( &mutex );
continue;
}
if ( config->use_knowledge_base_correlation_index != 0 )
{
AI_kb_index_init ( alerts );
}
__AI_correlation_table_cleanup();
correlation_table = NULL;
/* Fill the table of correlated alerts */
for ( alert_iterator = alerts; alert_iterator; alert_iterator = alert_iterator->next )
{
for ( alert_iterator2 = alerts; alert_iterator2; alert_iterator2 = alert_iterator2->next )
{
if ( alert_iterator != alert_iterator2 && ! (
alert_iterator->gid == alert_iterator2->gid &&
alert_iterator->sid == alert_iterator2->sid &&
alert_iterator->rev == alert_iterator2->rev ))
{
if ( !( corr = ( AI_alert_correlation* ) malloc ( sizeof ( AI_alert_correlation ))))
AI_fatal_err ( "Fatal dynamic memory allocation error", __FILE__, __LINE__ );
corr_key.a = alert_iterator;
corr_key.b = alert_iterator2;
corr->key = corr_key;
corr->correlation = 0.0;
n_correlations = 0;
kb_correlation = AI_kb_correlation_coefficient ( corr_key.a, corr_key.b );
bayesian_correlation = AI_alert_bayesian_correlation ( corr_key.a, corr_key.b );
neural_correlation = AI_alert_neural_som_correlation ( corr_key.a, corr_key.b );
/* Use the correlation indexes for which we have a value */
if ( bayesian_correlation != 0.0 && config->bayesianCorrelationInterval != 0 )
{
corr->correlation += AI_bayesian_correlation_weight() * bayesian_correlation;
n_correlations++;
}
if ( kb_correlation != 0.0 && config->use_knowledge_base_correlation_index )
{
corr->correlation += kb_correlation;
n_correlations++;
}
if ( neural_correlation != 0.0 && config->neuralNetworkTrainingInterval != 0 )
{
corr->correlation += AI_neural_correlation_weight() * neural_correlation;
n_correlations++;
}
/* Get the correlation indexes from extra correlation modules */
if (( corr_functions ))
{
for ( i=0; i < n_corr_functions; i++ )
{
if ( corr_weights[i]() != 0.0 )
{
corr->correlation += corr_weights[i]() * corr_functions[i] ( corr_key.a, corr_key.b );
n_correlations++;
}
}
}
#ifdef HAVE_LIBPYTHON2_6
if (( py_corr_functions ))
{
pyA = AI_alert_to_pyalert ( corr_key.a );
pyB = AI_alert_to_pyalert ( corr_key.b );
if ( pyA && pyB )
{
for ( i=0; i < n_py_corr_functions; i++ )
{
if ( !( pArgs = Py_BuildValue ( "(OO)", pyA, pyB )))
{
PyErr_Print();
AI_fatal_err ( "Could not initialize the Python arguments for the call", __FILE__, __LINE__ );
}
if ( !( pRet = PyEval_CallObject ( py_corr_functions[i], pArgs )))
{
PyErr_Print();
AI_fatal_err ( "Could not call the correlation function from the Python module", __FILE__, __LINE__ );
}
if ( !( PyArg_Parse ( pRet, "d", &py_value )))
{
PyErr_Print();
AI_fatal_err ( "Could not parse the correlation value out of the Python correlation function", __FILE__, __LINE__ );
}
Py_DECREF ( pRet );
Py_DECREF ( pArgs );
if ( !( pRet = PyEval_CallObject ( py_weight_functions[i], (PyObject*) NULL )))
{
PyErr_Print();
AI_fatal_err ( "Could not call the correlation function from the Python module", __FILE__, __LINE__ );
}
if ( !( PyArg_Parse ( pRet, "d", &py_weight )))
{
PyErr_Print();
AI_fatal_err ( "Could not parse the correlation weight out of the Python correlation function", __FILE__, __LINE__ );
}
Py_DECREF ( pRet );
if ( py_weight != 0.0 )
{
corr->correlation += py_weight * py_value;
n_correlations++;
}
}
Py_DECREF ( pyA ); Py_DECREF ( pyB );
/* free ( pyA ); free ( pyB ); */
pyA = NULL; pyB = NULL;
}
}
#endif
if ( n_correlations != 0 )
{
corr->correlation /= (double) n_correlations;
}
HASH_ADD ( hh, correlation_table, key, sizeof ( AI_alert_correlation_key ), corr );
}
}
}
if ( HASH_COUNT ( correlation_table ) > 0 )
{
avg_correlation = 0.0;
std_deviation = 0.0;
/* Compute the average correlation coefficient */
for ( corr = correlation_table; corr; corr = ( AI_alert_correlation* ) corr->hh.next )
{
avg_correlation += corr->correlation;
}
avg_correlation /= (double) HASH_COUNT ( correlation_table );
/* Compute the standard deviation */
for ( corr = correlation_table; corr; corr = ( AI_alert_correlation* ) corr->hh.next )
{
std_deviation += ( corr->correlation - avg_correlation ) * ( corr->correlation - avg_correlation );
}
std_deviation = sqrt ( std_deviation / (double) HASH_COUNT ( correlation_table ));
corr_threshold = avg_correlation + ( config->correlationThresholdCoefficient * std_deviation );
snprintf ( corr_dot_file, sizeof ( corr_dot_file ), "%s/correlated_alerts.dot", config->corr_alerts_dir );
if ( stat ( config->corr_alerts_dir, &st ) < 0 )
{
if ( mkdir ( config->corr_alerts_dir, 0755 ) < 0 )
{
AI_fatal_err ( "Unable to create directory the correlated alerts directory", __FILE__, __LINE__ );
}
} else if ( !S_ISDIR ( st.st_mode )) {
AI_fatal_err ( "The specified directory for correlated alerts is not a directory", __FILE__, __LINE__ );
}
if ( !( fp = fopen ( corr_dot_file, "w" )))
AI_fatal_err ( "Could not write on the correlated alerts .dot file", __FILE__, __LINE__ );
fprintf ( fp, "digraph G {\n" );
/* Find correlated alerts */
for ( corr = correlation_table; corr; corr = ( AI_alert_correlation* ) corr->hh.next )
{
pair_key.from_sid = corr->key.a->sid;
pair_key.from_gid = corr->key.a->gid;
pair_key.from_rev = corr->key.a->rev;
pair_key.to_sid = corr->key.b->sid;
pair_key.to_gid = corr->key.b->gid;
pair_key.to_rev = corr->key.b->rev;
HASH_FIND ( hh, manual_correlations, &pair_key, sizeof ( pair_key ), pair );
HASH_FIND ( hh, manual_uncorrelations, &pair_key, sizeof ( pair_key ), unpair );
/* Yes, BlackLight wrote this line of code in a pair of minutes and immediately
* compiled it without a single error */
if ( !unpair && ( pair || (
corr->correlation >= corr_threshold &&
corr_threshold != 0.0 &&
corr->key.a->timestamp <= corr->key.b->timestamp && ! (
corr->key.a->gid == corr->key.b->gid &&
corr->key.a->sid == corr->key.b->sid &&
corr->key.a->rev == corr->key.b->rev ) && (
corr->key.a->ip_src_addr == corr->key.b->ip_src_addr || (
(corr->key.a->h_node[src_addr] && corr->key.b->h_node[src_addr]) ?
( corr->key.a->h_node[src_addr]->max_val == corr->key.b->h_node[src_addr]->max_val &&
corr->key.a->h_node[src_addr]->min_val == corr->key.b->h_node[src_addr]->min_val ) : 0
)) && (
corr->key.a->ip_dst_addr == corr->key.b->ip_dst_addr || (
(corr->key.a->h_node[dst_addr] && corr->key.b->h_node[dst_addr]) ?
( corr->key.a->h_node[dst_addr]->max_val == corr->key.b->h_node[dst_addr]->max_val &&
corr->key.a->h_node[dst_addr]->min_val == corr->key.b->h_node[dst_addr]->min_val ) : 0
))
)
)
) {
if ( !( corr->key.a->derived_alerts = ( AI_snort_alert** ) realloc ( corr->key.a->derived_alerts,
(++corr->key.a->n_derived_alerts) * sizeof ( AI_snort_alert* ))))
AI_fatal_err ( "Fatal dynamic memory allocation error", __FILE__, __LINE__ );
if ( !( corr->key.b->parent_alerts = ( AI_snort_alert** ) realloc ( corr->key.b->parent_alerts,
(++corr->key.b->n_parent_alerts) * sizeof ( AI_snort_alert* ))))
AI_fatal_err ( "Fatal dynamic memory allocation error", __FILE__, __LINE__ );
corr->key.a->derived_alerts[ corr->key.a->n_derived_alerts - 1 ] = corr->key.b;
corr->key.b->parent_alerts [ corr->key.b->n_parent_alerts - 1 ] = corr->key.a;
__AI_correlated_alerts_to_dot ( corr, fp );
if ( config->outdbtype != outdb_none )
{
AI_store_correlation_to_db ( corr );
}
}
}
fprintf ( fp, "}\n" );
fclose ( fp );
#ifdef HAVE_LIBGVC
snprintf ( corr_png_file, sizeof ( corr_png_file ), "%s/correlated_alerts.png", config->corr_alerts_dir );
snprintf ( corr_ps_file , sizeof ( corr_ps_file ), "%s/correlated_alerts.ps" , config->corr_alerts_dir );
if ( !( gvc = gvContext() ))
{
pthread_mutex_unlock ( &mutex );
continue;
}
if ( !( fp = fopen ( corr_dot_file, "r" )))
{
pthread_mutex_unlock ( &mutex );
continue;
}
if ( !( g = agread ( fp )))
{
pthread_mutex_unlock ( &mutex );
continue;
}
gvLayout ( gvc, g, "dot" );
gvRenderFilename ( gvc, g, "png", corr_png_file );
gvRenderFilename ( gvc, g, "ps" , corr_ps_file );
gvFreeLayout ( gvc, g );
agclose ( g );
fclose ( fp );
#endif
/* If no database output is defined, then the alerts have no alert_id, so we cannot use the
* web interface for correlating them, as they have no unique identifier */
if ( config->outdbtype != outdb_none )
{
if ( strlen ( config->webserv_dir ) != 0 )
{
__AI_correlated_alerts_to_json ();
}
}
}
pthread_mutex_unlock ( &mutex );
}
pthread_exit (( void* ) 0 );
return (void*) 0;
} /* ----- end of function AI_alert_correlation_thread ----- */
int main(int argc, char **argv)
{
int c;
char *progname;
ingraph_state ig;
Agraph_t *graph;
Agnode_t *node;
Agedge_t *edge;
Agedge_t *nexte;
Agsym_t *attr;
char **files;
generic_list_t *attr_list;
generic_list_t *node_list;
unsigned long i, j;
opterr = 0;
progname = strrchr(argv[0], '/');
if (progname == NULL) {
progname = argv[0];
} else {
progname++; /* character after last '/' */
}
attr_list = new_generic_list(16);
node_list = new_generic_list(16);
while ((c = getopt(argc, argv, "hvn:N:")) != -1) {
switch (c) {
case 'N':
{
attr_list = addattr(attr_list, optarg);
break;
}
case 'n':
{
node_list = addnode(node_list, optarg);
break;
}
case 'h':
{
help_message(progname);
exit(EXIT_SUCCESS);
break;
}
case 'v':
{
verbose = 1;
break;
}
case '?':
if (isprint(optopt)) {
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
} else {
fprintf(stderr, "Unknown option character `\\x%X'.\n",
optopt);
}
exit(EXIT_FAILURE);
break;
default:
help_message(progname);
exit(EXIT_FAILURE);
break;
}
}
/* Any arguments left? */
if (optind < argc) {
files = &argv[optind];
} else {
files = NULL;
}
newIngraph(&ig, files, gread);
while ((graph = nextGraph(&ig)) != NULL) {
if (agisdirected(graph) == 0) {
fprintf(stderr,
"*** Error: Graph is undirected! Pruning works only with directed graphs!\n");
exit(EXIT_FAILURE);
}
/* attach node data for marking to all nodes */
aginit(graph, AGNODE, NDNAME, sizeof(ndata), 1);
/* prune all nodes specified on the commandline */
for (i = 0; i < node_list->used; i++) {
if (verbose == 1)
fprintf(stderr, "Pruning node %s\n",
(char *) node_list->data[i]);
/* check whether a node of that name exists at all */
node = agnode(graph, (char *) node_list->data[i], 0);
if (node == NULL) {
fprintf(stderr,
"*** Warning: No such node: %s -- gracefully skipping this one\n",
(char *) node_list->data[i]);
} else {
MARK(node); /* Avoid cycles */
/* Iterate over all outgoing edges */
for (edge = agfstout(node); edge; edge = nexte) {
nexte = agnxtout(edge);
if (aghead(edge) != node) { /* non-loop edges */
if (verbose == 1)
fprintf(stderr, "Processing descendant: %s\n",
agnameof(aghead(edge)));
remove_child(graph, aghead(edge));
agdelete(graph, edge);
}
}
UNMARK(node); /* Unmark so that it can be removed in later passes */
/* Change attribute (e.g. border style) to show that node has been pruneed */
for (j = 0; j < attr_list->used; j++) {
/* create attribute if it doesn't exist and set it */
attr =
agattr(graph, AGNODE,
((strattr_t *) attr_list->data[j])->n, "");
if (attr == NULL) {
fprintf(stderr, "Couldn't create attribute: %s\n",
((strattr_t *) attr_list->data[j])->n);
exit(EXIT_FAILURE);
}
agxset(node, attr,
((strattr_t *) attr_list->data[j])->v);
}
}
}
agwrite(graph, stdout);
agclose(graph);
}
free(attr_list);
free(node_list);
exit(EXIT_SUCCESS);
}
/*
* Close a graph or subgraph, freeing its storage.
*/
int agclose(Agraph_t * g)
{
Agraph_t *subg, *next_subg, *par;
Agnode_t *n, *next_n;
agflatten(g, FALSE);
par = agparent(g);
if ((par == NILgraph) && (AGDISC(g, mem)->close)) {
/* free entire heap */
agmethod_delete(g, g); /* invoke user callbacks */
agfreeid(g, AGRAPH, AGID(g));
AGDISC(g, mem)->close(AGCLOS(g, mem)); /* whoosh */
return SUCCESS;
}
for (subg = agfstsubg(g); subg; subg = next_subg) {
next_subg = agnxtsubg(subg);
agclose(subg);
}
for (n = agfstnode(g); n; n = next_n) {
next_n = agnxtnode(n);
agdelnode(n);
}
aginternalmapclose(g);
agmethod_delete(g, g);
assert(dtsize(g->n_id) == 0);
agdtclose(g, g->n_id);
assert(dtsize(g->n_seq) == 0);
agdtclose(g, g->n_seq);
assert(dtsize(g->e_id) == 0);
agdtclose(g, g->e_id);
assert(dtsize(g->e_seq) == 0);
agdtclose(g, g->e_seq);
assert(dtsize(g->g_dict) == 0);
agdtclose(g, g->g_dict);
if (g->desc.has_attrs)
agraphattr_delete(g);
agrecclose((Agobj_t *) g);
agfreeid(g, AGRAPH, AGID(g));
if (par) {
agdelsubg(par, g);
agfree(par, g);
} else {
Agmemdisc_t *memdisc;
void *memclos, *clos;
while (g->clos->cb)
agpopdisc(g, g->clos->cb->f);
AGDISC(g, id)->close(AGCLOS(g, id));
agstrclose(g);
memdisc = AGDISC(g, mem);
memclos = AGCLOS(g, mem);
clos = g->clos;
(memdisc->free) (memclos, g);
(memdisc->free) (memclos, clos);
}
return SUCCESS;
}
xbt_dynar_t SD_dotload_generic(const char* filename, bool sequential, bool schedule)
{
xbt_assert(filename, "Unable to use a null file descriptor\n");
FILE *in_file = fopen(filename, "r");
xbt_assert(in_file != nullptr, "Failed to open file: %s", filename);
SD_task_t root;
SD_task_t end;
SD_task_t task;
std::vector<SD_task_t>* computer;
std::unordered_map<std::string, std::vector<SD_task_t>*> computers;
bool schedule_success = true;
std::unordered_map<std::string, SD_task_t> jobs;
xbt_dynar_t result = xbt_dynar_new(sizeof(SD_task_t), dot_task_p_free);
Agraph_t * dag_dot = agread(in_file, NIL(Agdisc_t *));
/* Create all the nodes */
Agnode_t *node = nullptr;
for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
char *name = agnameof(node);
double amount = atof(agget(node, (char*)"size"));
if (jobs.find(name) == jobs.end()) {
if (sequential) {
XBT_DEBUG("See <job id=%s amount =%.0f>", name, amount);
task = SD_task_create_comp_seq(name, nullptr , amount);
} else {
double alpha = atof(agget(node, (char *) "alpha"));
XBT_DEBUG("See <job id=%s amount =%.0f alpha = %.3f>", name, amount, alpha);
task = SD_task_create_comp_par_amdahl(name, nullptr , amount, alpha);
}
jobs.insert({std::string(name), task});
if (strcmp(name,"root") && strcmp(name,"end"))
xbt_dynar_push(result, &task);
if ((sequential) &&
((schedule && schedule_success) || XBT_LOG_ISENABLED(sd_dotparse, xbt_log_priority_verbose))) {
/* try to take the information to schedule the task only if all is right*/
char *char_performer = agget(node, (char *) "performer");
char *char_order = agget(node, (char *) "order");
/* Tasks will execute on in a given "order" on a given set of "performer" hosts */
int performer = ((not char_performer || not strcmp(char_performer, "")) ? -1 : atoi(char_performer));
int order = ((not char_order || not strcmp(char_order, "")) ? -1 : atoi(char_order));
if ((performer != -1 && order != -1) && performer < static_cast<int>(sg_host_count())) {
/* required parameters are given and less performers than hosts are required */
XBT_DEBUG ("Task '%s' is scheduled on workstation '%d' in position '%d'", task->name, performer, order);
auto comp = computers.find(char_performer);
if (comp != computers.end()) {
computer = comp->second;
} else {
computer = new std::vector<SD_task_t>;
computers.insert({char_performer, computer});
}
if (static_cast<unsigned int>(order) < computer->size()) {
SD_task_t task_test = computer->at(order);
if (task_test && task_test != task) {
/* the user gave the same order to several tasks */
schedule_success = false;
XBT_VERB("Task '%s' wants to start on performer '%s' at the same position '%s' as task '%s'",
task_test->name, char_performer, char_order, task->name);
continue;
}
} else
computer->resize(order);
computer->insert(computer->begin() + order, task);
} else {
/* one of required parameters is not given */
schedule_success = false;
XBT_VERB("The schedule is ignored, task '%s' can not be scheduled on %d hosts", task->name, performer);
}
}
} else {
XBT_WARN("Task '%s' is defined more than once", name);
}
}
/*Check if 'root' and 'end' nodes have been explicitly declared. If not, create them. */
if (jobs.find("root") == jobs.end())
root = (sequential ? SD_task_create_comp_seq("root", nullptr, 0)
: SD_task_create_comp_par_amdahl("root", nullptr, 0, 0));
else
root = jobs.at("root");
SD_task_set_state(root, SD_SCHEDULABLE); /* by design the root task is always SCHEDULABLE */
xbt_dynar_insert_at(result, 0, &root); /* Put it at the beginning of the dynar */
if (jobs.find("end") == jobs.end())
end = (sequential ? SD_task_create_comp_seq("end", nullptr, 0)
: SD_task_create_comp_par_amdahl("end", nullptr, 0, 0));
else
end = jobs.at("end");
/* Create edges */
std::vector<Agedge_t*> edges;
for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
edges.clear();
for (Agedge_t* edge = agfstout(dag_dot, node); edge; edge = agnxtout(dag_dot, edge))
edges.push_back(edge);
/* Be sure edges are sorted */
std::sort(edges.begin(), edges.end(), [](const Agedge_t* a, const Agedge_t* b) { return AGSEQ(a) < AGSEQ(b); });
for (Agedge_t* edge : edges) {
char *src_name=agnameof(agtail(edge));
char *dst_name=agnameof(aghead(edge));
double size = atof(agget(edge, (char *) "size"));
SD_task_t src = jobs.at(src_name);
SD_task_t dst = jobs.at(dst_name);
if (size > 0) {
std::string name = std::string(src_name) + "->" + dst_name;
XBT_DEBUG("See <transfer id=%s amount = %.0f>", name.c_str(), size);
if (jobs.find(name) == jobs.end()) {
if (sequential)
task = SD_task_create_comm_e2e(name.c_str(), nullptr, size);
else
task = SD_task_create_comm_par_mxn_1d_block(name.c_str(), nullptr, size);
SD_task_dependency_add(src, task);
SD_task_dependency_add(task, dst);
jobs.insert({name, task});
xbt_dynar_push(result, &task);
} else {
XBT_WARN("Task '%s' is defined more than once", name.c_str());
}
} else {
SD_task_dependency_add(src, dst);
}
}
}
XBT_DEBUG("All tasks have been created, put %s at the end of the dynar", end->name);
xbt_dynar_push(result, &end);
/* Connect entry tasks to 'root', and exit tasks to 'end'*/
unsigned i;
xbt_dynar_foreach (result, i, task){
if (task->predecessors->empty() && task->inputs->empty() && task != root) {
XBT_DEBUG("Task '%s' has no source. Add dependency from 'root'", task->name);
SD_task_dependency_add(root, task);
}
if (task->successors->empty() && task->outputs->empty() && task != end) {
XBT_DEBUG("Task '%s' has no destination. Add dependency to 'end'", task->name);
SD_task_dependency_add(task, end);
}
}
agclose(dag_dot);
fclose(in_file);
if(schedule){
if (schedule_success) {
std::vector<simgrid::s4u::Host*> hosts = simgrid::s4u::Engine::get_instance()->get_all_hosts();
for (auto const& elm : computers) {
SD_task_t previous_task = nullptr;
for (auto const& cur_task : *elm.second) {
/* add dependency between the previous and the task to avoid parallel execution */
if (cur_task) {
if (previous_task && not SD_task_dependency_exists(previous_task, cur_task))
SD_task_dependency_add(previous_task, cur_task);
SD_task_schedulel(cur_task, 1, hosts[std::stod(elm.first)]);
previous_task = cur_task;
}
}
delete elm.second;
}
} else {
XBT_WARN("The scheduling is ignored");
for (auto const& elm : computers)
delete elm.second;
xbt_dynar_free(&result);
result = nullptr;
}
}
if (result && not acyclic_graph_detail(result)) {
std::string base = simgrid::xbt::Path(filename).get_base_name();
XBT_ERROR("The DOT described in %s is not a DAG. It contains a cycle.", base.c_str());
xbt_dynar_free(&result);
result = nullptr;
}
return result;
}
SBML_ODESOLVER_API int drawModel(Model_t *m, char* file, char *format) {
#if !USE_GRAPHVIZ
SolverError_error(
WARNING_ERROR_TYPE,
SOLVER_ERROR_NO_GRAPHVIZ,
"odeSolver has been compiled without GRAPHIZ functionality. ",
"Graphs are printed to stdout in the graphviz' .dot format.");
drawModelTxt(m, file);
#else
GVC_t *gvc;
Agraph_t *g;
Agnode_t *r;
Agnode_t *s;
Agedge_t *e;
Agsym_t *a;
Species_t *sp;
Reaction_t *re;
const ASTNode_t *math;
SpeciesReference_t *sref;
ModifierSpeciesReference_t *mref;
char *output[4];
char *command = "dot";
char *formatopt;
char *outfile;
int i,j;
int reversible;
char name[WORDSIZE];
char label[WORDSIZE];
/* setting name of outfile */
ASSIGN_NEW_MEMORY_BLOCK(outfile, strlen(file)+ strlen(format)+7, char, 0);
sprintf(outfile, "-o%s_rn.%s", file, format);
/* setting output format */
ASSIGN_NEW_MEMORY_BLOCK(formatopt, strlen(format)+3, char, 0);
sprintf(formatopt, "-T%s", format);
/* construct command-line */
output[0] = command;
output[1] = formatopt;
output[2] = outfile;
output[3] = NULL;
/* set up renderer context */
gvc = (GVC_t *) gvContext();
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION < 4
dotneato_initialize(gvc, 3, output);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
parse_args(gvc, 3, output);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvParseArgs(gvc, 3, output);
#endif
g = agopen("G", AGDIGRAPH);
/* avoid overlapping nodes, for graph embedding by neato */
a = agraphattr(g, "overlap", "");
agxset(g, a->index, "scale");
for ( i=0; i<Model_getNumReactions(m); i++ ) {
re = Model_getReaction(m,i);
reversible = Reaction_getReversible(re);
sprintf(name, "%s", Reaction_getId(re));
r = agnode(g,name);
a = agnodeattr(g, "shape", "ellipse");
agxset(r, a->index, "box");
sprintf(label, "%s", Reaction_isSetName(re) ?
Reaction_getName(re) : Reaction_getId(re));
agset(r, "label", label);
sprintf(label, "%s.htm", Reaction_getId(re));
a = agnodeattr(g, "URL", "");
agxset(r, a->index, label);
for ( j=0; j<Reaction_getNumModifiers(re); j++ ) {
mref = Reaction_getModifier(re,j);
sp = Model_getSpeciesById(m, ModifierSpeciesReference_getSpecies(mref));
sprintf(name,"%s", Species_getId(sp));
s = agnode(g,name);
sprintf(label, "%s", Species_isSetName(sp) ?
Species_getName(sp) : Species_getId(sp));
agset(s, "label", label);
if ( Species_getBoundaryCondition(sp) ) {
a = agnodeattr(g, "color", "");
agxset(s, a->index, "blue");
}
if ( Species_getConstant(sp) ) {
a = agnodeattr(g, "color", "");
agxset(s, a->index, "green4");
}
sprintf(label, "%s.htm", Species_getId(sp));
a = agnodeattr(g, "URL", "");
agxset(s, a->index, label);
e = agedge(g,s,r);
a = agedgeattr(g, "style", "");
agxset(e, a->index, "dashed");
a = agedgeattr(g, "arrowhead", "");
agxset(e, a->index, "odot");
}
for ( j=0; j<Reaction_getNumReactants(re); j++ ) {
sref = Reaction_getReactant(re,j);
sp = Model_getSpeciesById(m, SpeciesReference_getSpecies(sref));
sprintf(name,"%s", Species_getId(sp));
s = agnode(g, name);
sprintf(label, "%s", Species_isSetName(sp) ?
Species_getName(sp) : Species_getId(sp));
agset(s, "label", label);
if ( Species_getBoundaryCondition(sp) ) {
a = agnodeattr(g, "color", "");
agxset(s, a->index, "blue");
}
if ( Species_getConstant(sp) ) {
a = agnodeattr(g, "color", "");
agxset(s, a->index, "green4");
}
sprintf(label, "%s.htm", Species_getId(sp));
a = agnodeattr(g, "URL", "");
agxset(s, a->index, label);
e = agedge(g,s,r);
a = agedgeattr(g, "label", "");
if ( (SpeciesReference_isSetStoichiometryMath(sref)) ) {
math = SpeciesReference_getStoichiometryMath(sref);
if ( (strcmp(SBML_formulaToString(math),"1") !=
0) ) {
agxset (e, a->index, SBML_formulaToString(math));
}
}
else {
if ( SpeciesReference_getStoichiometry(sref) != 1 ) {
sprintf(name, "%g", SpeciesReference_getStoichiometry(sref));
agxset (e, a->index, name);
}
}
if ( reversible == 1 ) {
a = agedgeattr(g, "arrowtail", "");
agxset(e, a->index, "onormal");
}
}
for ( j=0; j<Reaction_getNumProducts(re); j++ ) {
sref = Reaction_getProduct(re,j);
sp = Model_getSpeciesById(m, SpeciesReference_getSpecies(sref));
sprintf(name,"%s", Species_getId(sp));
s = agnode(g,name);
sprintf(label, "%s", Species_isSetName(sp) ?
Species_getName(sp) : Species_getId(sp));
agset(s, "label", label);
if ( Species_getBoundaryCondition(sp) ) {
a = agnodeattr(g, "color", "");
agxset(s, a->index, "blue");
}
if ( Species_getConstant(sp) ) {
a = agnodeattr(g, "color", "");
agxset(s, a->index, "green4");
}
sprintf(label, "%s.htm", Species_getId(sp));
a = agnodeattr(g, "URL", "");
agxset(s, a->index, label);
e = agedge(g,r,s);
a = agedgeattr(g, "label", "");
if ( SpeciesReference_isSetStoichiometryMath(sref) ) {
math = SpeciesReference_getStoichiometryMath(sref);
if ( (strcmp(SBML_formulaToString(math),"1") !=
0) ) {
agxset (e, a->index, SBML_formulaToString(math));
}
}
else {
if ( SpeciesReference_getStoichiometry(sref) != 1 ) {
sprintf(name, "%g",SpeciesReference_getStoichiometry(sref));
agxset (e, a->index,name);
}
}
if ( reversible == 1 ) {
a = agedgeattr(g, "arrowtail", "");
agxset(e, a->index, "onormal");
}
}
}
/* Compute a layout */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
gvBindContext(gvc, g);
dot_layout(g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
gvlayout_layout(gvc, g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvLayoutJobs(gvc, g);
#endif
/* Write the graph according to -T and -o options */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
dotneato_write(gvc);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
emit_jobs(gvc, g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvRenderJobs(gvc, g);
#endif
/* Clean out layout data */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
dot_cleanup(g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
gvlayout_cleanup(gvc, g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvFreeLayout(gvc, g);
#endif
/* Free graph structures */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
dot_cleanup(g);
#else
agclose(g);
#endif
/* Clean up output file and errors */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
gvFREEcontext(gvc);
dotneato_eof(gvc);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
dotneato_terminate(gvc);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvFreeContext(gvc);
#endif
xfree(formatopt);
xfree(outfile);
#endif
return 1;
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e a d D O T I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadDOTImage() reads a Graphviz image file and returns it. It allocates
% the memory necessary for the new Image structure and returns a pointer to
% the new image.
%
% The format of the ReadDOTImage method is:
%
% Image *ReadDOTImage(const ImageInfo *image_info,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image_info: the image info.
%
% o exception: return any errors or warnings in this structure.
%
*/
static Image *ReadDOTImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
char
command[MagickPathExtent];
const char
*option;
graph_t
*graph;
Image
*image;
ImageInfo
*read_info;
MagickBooleanType
status;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
assert(graphic_context != (GVC_t *) NULL);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
return(DestroyImageList(image));
read_info=CloneImageInfo(image_info);
SetImageInfoBlob(read_info,(void *) NULL,0);
(void) CopyMagickString(read_info->magick,"SVG",MagickPathExtent);
(void) AcquireUniqueFilename(read_info->filename);
(void) FormatLocaleString(command,MagickPathExtent,"-Tsvg -o%s %s",
read_info->filename,image_info->filename);
#if !defined(WITH_CGRAPH)
graph=agread(GetBlobFileHandle(image));
#else
graph=agread(GetBlobFileHandle(image),(Agdisc_t *) NULL);
#endif
if (graph == (graph_t *) NULL)
{
(void) RelinquishUniqueFileResource(read_info->filename);
return(DestroyImageList(image));
}
option=GetImageOption(image_info,"dot:layout-engine");
if (option == (const char *) NULL)
gvLayout(graphic_context,graph,(char *) "dot");
else
gvLayout(graphic_context,graph,(char *) option);
gvRenderFilename(graphic_context,graph,(char *) "svg",read_info->filename);
gvFreeLayout(graphic_context,graph);
agclose(graph);
image=DestroyImageList(image);
/*
Read SVG graph.
*/
(void) CopyMagickString(read_info->magick,"SVG",MaxTextExtent);
image=ReadImage(read_info,exception);
(void) RelinquishUniqueFileResource(read_info->filename);
read_info=DestroyImageInfo(read_info);
if (image == (Image *) NULL)
return((Image *) NULL);
return(GetFirstImageInList(image));
}
int ggen_read_graph(igraph_t *g,FILE *input)
{
Agraph_t *cg;
Agnode_t *v;
Agedge_t *e;
igraph_vector_t edges;
igraph_vector_t vertices;
int err;
unsigned long esize;
unsigned long vsize;
unsigned long from, to;
igraph_integer_t eid;
Agsym_t *att;
/* read the graph */
cg = agread((void *)input,NULL);
if(!cg) return 1;
if(!agisdirected(cg))
{
error("Input graph is undirected\n");
err = 1;
goto error_d;
}
/* init edge array */
err = igraph_vector_init(&edges,2*agnedges(cg));
if(err) goto error_d;
err = igraph_vector_init(&vertices,agnnodes(cg));
if(err) goto error_de;
/* init igraph */
igraph_empty(g,agnnodes(cg),1);
/* asign id to each vertex */
vsize = 0;
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
VECTOR(vertices)[vsize++] = AGID(v);
/* loop through each edge */
esize = 0;
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
for(e = agfstout(cg,v); e; e = agnxtout(cg,e))
{
to = find_id(AGID(aghead(e)),vertices,vsize);
VECTOR(edges)[esize++] = from;
VECTOR(edges)[esize++] = to;
}
}
/* finish the igraph */
err = igraph_add_edges(g,&edges,NULL);
if(err) goto error;
/* read graph properties */
att = agnxtattr(cg,AGRAPH,NULL);
while(att != NULL)
{
/* copy this attribute to igraph */
SETGAS(g,att->name,agxget(cg,att));
att = agnxtattr(cg,AGRAPH,att);
}
/* we keep the graph name using a special attribute */
SETGAS(g,GGEN_GRAPH_NAME_ATTR,agnameof(cg));
/* read vertex properties */
att = agnxtattr(cg,AGNODE,NULL);
while(att != NULL)
{
/* iterate over all vertices for this attribute */
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
SETVAS(g,att->name,from,agxget(v,att));
}
att = agnxtattr(cg,AGNODE,att);
}
/* we keep each vertex name in a special attribute */
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
SETVAS(g,GGEN_VERTEX_NAME_ATTR,from,agnameof(v));
}
/* read edges properties */
att = agnxtattr(cg,AGEDGE,NULL);
while(att != NULL)
{
/* the only way to iterate over all edges is to iterate
* over the vertices */
for(v = agfstnode(cg); v; v = agnxtnode(cg,v))
{
from = find_id(AGID(v),vertices,vsize);
for(e = agfstout(cg,v); e; e = agnxtout(cg,e))
{
to = find_id(AGID(aghead(e)),vertices,vsize);
igraph_get_eid(g,&eid,from,to,1,0);
SETEAS(g,att->name,eid,agxget(e,att));
}
}
att = agnxtattr(cg,AGEDGE,att);
}
goto cleanup;
error:
igraph_destroy(g);
cleanup:
igraph_vector_destroy(&vertices);
error_de:
igraph_vector_destroy(&edges);
error_d:
agclose(cg);
return err;
}
/* mkConstraintG:
*/
static graph_t *mkConstraintG(graph_t * g, Dt_t * list,
intersectfn intersect, distfn dist)
{
nitem *p;
nitem *nxt = NULL;
nitem *nxp;
graph_t *vg;
node_t *prev = NULL;
node_t *root = NULL;
node_t *n = NULL;
edge_t *e;
int lcnt, cnt;
int oldval = -INT_MAX;
#ifdef OLD
double root_val;
#endif
node_t *lastn = NULL;
#ifndef WITH_CGRAPH
graph_t *cg = agopen("cg", AGDIGRAPHSTRICT);
#else
graph_t *cg = agopen("cg", Agstrictdirected, NIL(Agdisc_t *));
agbindrec(cg, "Agraphinfo_t", sizeof(Agraphinfo_t), TRUE); // graph custom data
#endif
/* count distinct nodes */
cnt = 0;
for (p = (nitem *) dtflatten(list); p;
p = (nitem *) dtlink(list, (Dtlink_t *) p)) {
if (oldval != p->val) {
oldval = p->val;
cnt++;
}
}
/* construct basic chain to enforce left to right order */
oldval = -INT_MAX;
lcnt = 0;
for (p = (nitem *) dtflatten(list); p;
p = (nitem *) dtlink(list, (Dtlink_t *) p)) {
if (oldval != p->val) {
oldval = p->val;
/* n = newNode (cg); */
#ifndef WITH_CGRAPH
n = agnode(cg, agnameof(p->np)); /* FIX */
#else
n = agnode(cg, agnameof(p->np), 1); /* FIX */
agbindrec(n, "Agnodeinfo_t", sizeof(Agnodeinfo_t), TRUE); //node custom data
#endif
ND_alg(n) = p;
if (root) {
ND_next(lastn) = n;
lastn = n;
} else {
root = n;
#ifdef OLD
root_val = p->val;
#endif
lastn = GD_nlist(cg) = n;
}
alloc_elist(lcnt, ND_in(n));
if (prev) {
if (prev == root)
alloc_elist(2 * (cnt - 1), ND_out(prev));
else
alloc_elist(cnt - lcnt - 1, ND_out(prev));
#ifndef WITH_CGRAPH
e = agedge(cg, prev, n);
#else
e = agedge(cg, prev, n, NULL, 1);
agbindrec(e, "Agedgeinfo_t", sizeof(Agedgeinfo_t), TRUE); // edge custom data
#endif
ED_minlen(e) = SCALE;
ED_weight(e) = 1;
elist_append(e, ND_out(prev));
elist_append(e, ND_in(n));
}
lcnt++;
prev = n;
}
p->cnode = n;
}
alloc_elist(0, ND_out(prev));
/* add immediate right neighbor constraints
* Construct visibility graph, then perform transitive reduction.
* Remaining outedges are immediate right neighbors.
* FIX: Incremental algorithm to construct trans. reduction?
*/
#ifndef WITH_CGRAPH
vg = agopen("vg", AGDIGRAPHSTRICT);
#else
vg = agopen("vg", Agstrictdirected, NIL(Agdisc_t *));
#endif
for (p = (nitem *) dtflatten(list); p;
p = (nitem *) dtlink(list, (Dtlink_t *) p)) {
#ifndef WITH_CGRAPH
n = agnode(vg, agnameof(p->np)); /* FIX */
#else
n = agnode(vg, agnameof(p->np), 1); /* FIX */
agbindrec(n, "Agnodeinfo_t", sizeof(Agnodeinfo_t), TRUE); //node custom data
#endif
p->vnode = n;
ND_alg(n) = p;
}
oldval = -INT_MAX;
for (p = (nitem *) dtflatten(list); p;
p = (nitem *) dtlink(list, (Dtlink_t *) p)) {
if (oldval != p->val) { /* new pos: reset nxt */
oldval = p->val;
for (nxt = (nitem *) dtlink(link, (Dtlink_t *) p); nxt;
nxt = (nitem *) dtlink(list, (Dtlink_t *) nxt)) {
if (nxt->val != oldval)
break;
}
if (!nxt)
break;
}
for (nxp = nxt; nxp;
nxp = (nitem *) dtlink(list, (Dtlink_t *) nxp)) {
if (intersect(p, nxp))
#ifndef WITH_CGRAPH
agedge(vg, p->vnode, nxp->vnode);
#else
agedge(vg, p->vnode, nxp->vnode, NULL, 1);
#endif
}
}
/* Remove redundant constraints here. However, the cost of doing this
* may be a good deal more than the time saved in network simplex. Also,
* if the graph is changed, the ND_in and ND_out data has to be updated.
*/
mapGraphs(vg, cg, dist);
agclose(vg);
/* add dummy constraints for absolute values and initial positions */
#ifdef OLD
for (n = agfstnode(cg); n; n = agnxtnode(cg, n)) {
node_t *vn; /* slack node for absolute value */
node_t *an; /* node representing original position */
p = (nitem *) ND_alg(n);
if ((n == root) || (!p))
continue;
vn = newNode(cg);
ND_next(lastn) = vn;
lastn = vn;
alloc_elist(0, ND_out(vn));
alloc_elist(2, ND_in(vn));
an = newNode(cg);
ND_next(lastn) = an;
lastn = an;
alloc_elist(1, ND_in(an));
alloc_elist(1, ND_out(an));
#ifndef WITH_CGRAPH
e = agedge(cg, root, an);
#else
e = agedge(cg, root, an, 1);
#endif
ED_minlen(e) = p->val - root_val;
elist_append(e, ND_out(root));
elist_append(e, ND_in(an));
#ifndef WITH_CGRAPH
e = agedge(cg, an, vn);
#else
e = agedge(cg, an, vn, 1);
#endif
elist_append(e, ND_out(an));
elist_append(e, ND_in(vn));
#ifndef WITH_CGRAPH
e = agedge(cg, n, vn);
#else
e = agedge(cg, n, vn, 1);
#endif
elist_append(e, ND_out(n));
elist_append(e, ND_in(vn));
}
#endif /* OLD */
return cg;
}
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 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);
}
/**
* \brief Close the graph structure
*
*/
void graph__close(Agraph_t* graph){
agclose(graph);
}
SBML_ODESOLVER_API int drawJacoby(cvodeData_t *data, char *file, char *format) {
#if !USE_GRAPHVIZ
SolverError_error(
WARNING_ERROR_TYPE,
SOLVER_ERROR_NO_GRAPHVIZ,
"odeSolver has been compiled without GRAPHIZ functionality. ",
"Graphs are printed to stdout in the graphviz' .dot format.");
drawJacobyTxt(data, file);
#else
int i, j;
GVC_t *gvc;
Agraph_t *g;
Agnode_t *r;
Agnode_t *s;
Agedge_t *e;
Agsym_t *a;
char name[WORDSIZE];
char label[WORDSIZE];
char *output[3];
char *command = "dot";
char *formatopt;
char *outfile;
/* setting name of outfile */
ASSIGN_NEW_MEMORY_BLOCK(outfile, strlen(file)+ strlen(format)+7, char, 0);
sprintf(outfile, "-o%s_jm.%s", file, format);
/* setting output format */
ASSIGN_NEW_MEMORY_BLOCK(formatopt, strlen(format)+3, char, 0);
sprintf(formatopt, "-T%s", format);
/* construct command-line */
output[0] = command;
output[1] = formatopt;
output[2] = outfile;
output[3] = NULL;
/* set up renderer context */
gvc = (GVC_t *) gvContext();
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION < 4
dotneato_initialize(gvc, 3, output);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
parse_args(gvc, 3, output);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvParseArgs(gvc, 3, output);
#endif
g = agopen("G", AGDIGRAPH);
/* avoid overlapping nodes, for graph embedding by neato */
a = agraphattr(g, "overlap", "");
agxset(g, a->index, "scale");
/* set graph label */
if ( Model_isSetName(data->model->m) )
sprintf(label, "%s at time %g", Model_getName(data->model->m),
data->currenttime);
else if ( Model_isSetId(data->model->m) )
sprintf(label, "%s at time %g", Model_getId(data->model->m),
data->currenttime);
else
sprintf(label, "label=\"at time %g\";\n", data->currenttime);
a = agraphattr(g, "label", "");
agxset(g, a->index, label);
/*
Set edges from species A to species B if the
corresponding entry in the jacobian ((d[B]/dt)/d[A])
is not '0'. Set edge color 'red' and arrowhead 'tee'
if negative.
*/
for ( i=0; i<data->model->neq; i++ ) {
for ( j=0; j<data->model->neq; j++ ) {
if ( evaluateAST(data->model->jacob[i][j], data) != 0 ) {
sprintf(name, "%s", data->model->names[j]);
r = agnode(g,name);
agset(r, "label", data->model->names[j]);
sprintf(label, "%s.htm", data->model->names[j]);
a = agnodeattr(g, "URL", "");
agxset(r, a->index, label);
sprintf(name,"%s", data->model->names[i]);
s = agnode(g,name);
agset(s, "label", data->model->names[i]);
sprintf(label, "%s.htm", data->model->names[i]);
a = agnodeattr(g, "URL", "");
agxset(s, a->index, label);
e = agedge(g,r,s);
a = agedgeattr(g, "label", "");
sprintf(name, "%g", evaluateAST(data->model->jacob[i][j], data));
agxset (e, a->index, name);
if ( evaluateAST(data->model->jacob[i][j], data) < 0 ) {
a = agedgeattr(g, "arrowhead", "");
agxset(e, a->index, "tee");
a = agedgeattr(g, "color", "");
agxset(e, a->index, "red");
}
}
}
}
/* Compute a layout */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
gvBindContext(gvc, g);
dot_layout(g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
gvlayout_layout(gvc, g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvLayoutJobs(gvc, g);
#endif
/* Write the graph according to -T and -o options */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
dotneato_write(gvc);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
emit_jobs(gvc, g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvRenderJobs(gvc, g);
#endif
/* Clean out layout data */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
dot_cleanup(g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
gvlayout_cleanup(gvc, g);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6 || GRAPHVIZ_MAJOR_VERSION >= 3
gvFreeLayout(gvc, g);
#endif
/* Free graph structures */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
dot_cleanup(g);
#endif
agclose(g);
/* Clean up output file and errors */
#if GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION <= 2
gvFREEcontext(gvc);
dotneato_eof(gvc);
#elif GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION == 4
dotneato_terminate(gvc);
#elif (GRAPHVIZ_MAJOR_VERSION == 2 && GRAPHVIZ_MINOR_VERSION >= 6) || GRAPHVIZ_MAJOR_VERSION >= 3
gvFreeContext(gvc);
#endif
xfree(formatopt);
xfree(outfile);
#endif
return 1;
}
GVLayout::~GVLayout()
{
agclose(this->gvgraph);
gvFreeContext (this->gvc);
}
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;
}
void GraphvizAdapterImpl::finalize_graph_() {
if (g_) {
agclose(g_);
g_ = NULL;
}
}
nodelist_t *layout_block(Agraph_t * g, block_t * sn, double min_dist)
{
Agnode_t *n;
Agraph_t *copyG, *tree, *subg;
nodelist_t *longest_path;
nodelistitem_t *item;
int N, k;
double theta, radius, largest_node;
largest_node = 0;
subg = sn->sub_graph;
block_graph(g, sn); /* add induced edges */
copyG = remove_pair_edges(subg);
tree = spanning_tree(copyG);
longest_path = find_longest_path(tree);
place_residual_nodes(subg, longest_path);
/* at this point, longest_path is a list of all nodes in the block */
/* apply crossing reduction algorithms here */
longest_path = reduce_edge_crossings(longest_path, subg);
N = sizeNodelist(longest_path);
largest_node = largest_nodesize(longest_path);
/* N*(min_dist+largest_node) is roughly circumference of required circle */
if (N == 1)
radius = 0;
else
radius = (N * (min_dist + largest_node)) / (2 * PI);
for (item = longest_path->first; item; item = item->next) {
n = item->curr;
if (ISPARENT(n)) {
/* QUESTION: Why is only one parent realigned? */
realignNodelist(longest_path, item);
break;
}
}
k = 0;
for (item = longest_path->first; item; item = item->next) {
n = item->curr;
POSITION(n) = k;
PSI(n) = 0.0;
theta = k * ((2.0 * PI) / N);
ND_pos(n)[0] = radius * cos(theta);
ND_pos(n)[1] = radius * sin(theta);
k++;
}
if (N == 1)
sn->radius = largest_node / 2;
else
sn->radius = radius;
sn->rad0 = sn->radius;
/* initialize parent pos */
sn->parent_pos = -1;
agclose(copyG);
return longest_path;
}
GVSubGraph::~GVSubGraph() {
agclose(_graph);
}
grafo le_grafo(FILE *input) {
Agraph_t *ag = agread(input, 0);
if(!(ag && agisstrict(ag)))
return NULL;
// struct grafo *g = malloc(sizeof(struct grafo));
grafo g = malloc(sizeof(struct grafo));
if( !g ) return NULL;
g->vertices = constroi_lista();
g->nome = malloc(sizeof(char) * strlen(agnameof(ag)+1));
strcpy(g->nome, agnameof(ag));
g->direcionado = agisdirected(ag);
g->n_vertices = (unsigned int)agnnodes(ag);
g->n_arestas = (unsigned int)agnedges(ag);
g->ponderado = 0;
for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){
vertice vt = malloc(sizeof(struct vertice));
vt->nome = malloc(sizeof(char) * strlen(agnameof(v))+1);
strcpy( vt->nome, agnameof(v) );
vt->visitado = 0;
vt->coberto = 0;
vt->arestas_saida = constroi_lista();
vt->arestas_entrada = constroi_lista();
insere_lista(vt, g->vertices);
}
for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){
vertice vt = busca_vertice(g->vertices, agnameof(v));
if( g-> direcionado ){
for( Agedge_t *e = agfstout(ag,v); e; e = agnxtout(ag,e) ){
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, vt->arestas_saida);
}
for( Agedge_t *e = agfstin(ag,v); e; e = agnxtin(ag,e) ){
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, vt->arestas_entrada);
}
}
else {
for( Agedge_t *e = agfstedge(ag,v); e; e = agnxtedge(ag,e,v) ){
if( agtail(e) != v ) continue;
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, at->origem->arestas_saida);
insere_lista(at, at->destino->arestas_saida);
}
}
}
if( agclose(ag) )
return NULL;
return g;
}
