//------------------------------------------------------------------------------ static Agraph_t *mostra_grafo(Agraph_t *g) { if ( ! g ) return NULL; direcionado = agisdirected(g); n_vertices = agnnodes(g); n_arestas = agnedges(g); lista_arestas = constroi_lista(); printf("strict %sgraph \"%s\" {\n\n", agisdirected(g) ? "di" : "", agnameof(g) ); mostra_vertices(g); printf("\n"); mostra_arestas(); printf("}\n"); destroi_lista(lista_arestas, NULL); return g; }
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; }
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"); }
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; }
static char *nameOf(void *obj, agxbuf * xb) { Agedge_t *ep; switch (agobjkind(obj)) { #ifndef WITH_CGRAPH case AGGRAPH: #else case AGRAPH: #endif agxbput(xb, agnameof(((Agraph_t *) obj))); break; case AGNODE: agxbput(xb, agnameof(((Agnode_t *) obj))); break; case AGEDGE: ep = (Agedge_t *) obj; agxbput(xb, agnameof(agtail(ep))); agxbput(xb, agnameof(aghead(ep))); if (agisdirected(agraphof(aghead(ep)))) agxbput(xb, "->"); else agxbput(xb, "--"); break; } return agxbuse(xb); }
int main(int argc, char *argv[]) { Agraph_t *g; Agnode_t *n; int rv = 0; init(argc, argv); if ((g = agread(inFile, (Agdisc_t *) 0)) != 0) { if (agisdirected (g)) { aginit(g, AGNODE, "info", sizeof(Agnodeinfo_t), TRUE); for (n = agfstnode(g); n; n = agnxtnode(g, n)) { if (ND_mark(n) == 0) rv |= dfs(g, n, 0); } if (doWrite) { agwrite(g, outFile); fflush(outFile); } if (Verbose) { if (rv) fprintf(stderr, "Graph \"%s\" has cycles; %d reversed edges\n", graphName(g), num_rev); else fprintf(stderr, "Graph \"%s\" is acyclic\n", graphName(g)); } } else { rv = -1; if (Verbose) fprintf(stderr, "Graph \"%s\" is undirected\n", graphName(g)); } exit(rv); } else exit(-1); }
void tcldot_layout(GVC_t *gvc, Agraph_t * g, char *engine) { char buf[256]; Agsym_t *a; int rc; gvFreeLayout(gvc, g); /* in case previously drawn */ /* support old behaviors if engine isn't specified*/ if (!engine || *engine == '\0') { if (agisdirected(g)) rc = gvlayout_select(gvc, "dot"); else rc = gvlayout_select(gvc, "neato"); } else { if (strcasecmp(engine, "nop") == 0) { Nop = 2; PSinputscale = POINTS_PER_INCH; rc = gvlayout_select(gvc, "neato"); } else { rc = gvlayout_select(gvc, engine); } if (rc == NO_SUPPORT) rc = gvlayout_select(gvc, "dot"); } if (rc == NO_SUPPORT) { fprintf(stderr, "Layout type: \"%s\" not recognized. Use one of:%s\n", engine, gvplugin_list(gvc, API_layout, engine)); return; } gvLayoutJobs(gvc, g); /* set bb attribute for basic layout. * doesn't yet include margins, scaling or page sizes because * those depend on the renderer being used. */ if (GD_drawing(g)->landscape) sprintf(buf, "%d %d %d %d", ROUND(GD_bb(g).LL.y), ROUND(GD_bb(g).LL.x), ROUND(GD_bb(g).UR.y), ROUND(GD_bb(g).UR.x)); else sprintf(buf, "%d %d %d %d", ROUND(GD_bb(g).LL.x), ROUND(GD_bb(g).LL.y), ROUND(GD_bb(g).UR.x), ROUND(GD_bb(g).UR.y)); if (!(a = agattr(g, AGRAPH, "bb", NULL))) a = agattr(g, AGRAPH, "bb", ""); agxset(g, a, buf); }
static void write_hdr(Agraph_t * g, GVJ_t * job, int top, state_t* sp) { char *name; name = agnameof(g); indent(job, sp->Level); gvprintf(job, "\"name\": \"%s\"", stoj (name, sp)); if (top) { gvputs(job, ",\n"); indent(job, sp->Level); gvprintf(job, "\"directed\": %s,\n", (agisdirected(g)?"true":"false")); indent(job, sp->Level); gvprintf(job, "\"strict\": %s", (agisstrict(g)?"true":"false")); } }
int gvToolTred(Agraph_t * g) { Agnode_t *n; int warn = 0; if (agisdirected(g)) { aginit(g, AGNODE, "info", sizeof(Agmarknodeinfo_t), TRUE); for (n = agfstnode(g); n; n = agnxtnode(g, n)) { warn = dfs(n, NULL, warn); } agclean(g, AGNODE, "info"); } else { fprintf(stderr, "warning: %s is not a directed graph, not attempting tred\n", agnameof(g)); } return 0; // FIXME - return proper errors }
//------------------------------------------------------------------------------ grafo le_grafo(FILE *input) { Agraph_t *g; grafo grafo_lido; char peso_string[] = "peso"; /* Aloca estrutura do grafo lido */ grafo_lido = (grafo) malloc(sizeof(struct grafo)); if(grafo_lido != NULL) { /* Armazena em g o grafo lido da entrada */ if((g = agread(input, NULL)) == NULL) { destroi_grafo(grafo_lido); return NULL; } /* Carrega na estrutura os vértices de g */ if((grafo_lido->grafo_vertices = obter_vertices(g, &(grafo_lido->grafo_n_vertices))) == NULL) { agclose(g); destroi_grafo(grafo_lido); return NULL; } /* Verifica se g é um grafo ponderado ou não */ if(agattr(g, AGEDGE, peso_string, (char *) NULL) != NULL) { grafo_lido->grafo_ponderado = 1; } else { grafo_lido->grafo_ponderado = 0; } /* Define o nome do grafo e se ele é direcionado */ grafo_lido->grafo_direcionado = agisdirected(g); grafo_lido->grafo_nome = strdup(agnameof(g)); /* Carrega na estrutura a matriz de adjacência de g */ if((grafo_lido->grafo_matriz = obter_matriz_adjacencia(g, grafo_lido->grafo_vertices, grafo_lido->grafo_ponderado, grafo_lido->grafo_direcionado, grafo_lido->grafo_n_vertices)) == NULL) { agclose(g); destroi_grafo(grafo_lido); return NULL; } agclose(g); } return grafo_lido; }
int main(int argc, char **argv) { Agraph_t* g; ingraph_state ig; scanArgs(argc,argv); newIngraph (&ig, Files, gread); while ((g = nextGraph(&ig)) != 0) { if (agisdirected(g)) process (g); else fprintf (stderr, "Graph %s in %s is undirected - ignored\n", agnameof(g), fileName(&ig)); agclose (g); } return 0; }
/* strdup_and_subst_obj0: * Replace various escape sequences with the name of the associated * graph object. A double backslash \\ can be used to avoid a replacement. * If escBackslash is true, convert \\ to \; else leave alone. All other dyads * of the form \. are passed through unchanged. */ static char *strdup_and_subst_obj0 (char *str, void *obj, int escBackslash) { char c, *s, *p, *t, *newstr; char *tp_str = "", *hp_str = ""; char *g_str = "\\G", *n_str = "\\N", *e_str = "\\E", *h_str = "\\H", *t_str = "\\T", *l_str = "\\L"; int g_len = 2, n_len = 2, e_len = 2, h_len = 2, t_len = 2, l_len = 2, tp_len = 0, hp_len = 0; int newlen = 0; int isEdge = 0; textlabel_t *tl; port pt; /* prepare substitution strings */ switch (agobjkind(obj)) { case AGRAPH: g_str = agnameof((graph_t *)obj); g_len = strlen(g_str); tl = GD_label((graph_t *)obj); if (tl) { l_str = tl->text; if (str) l_len = strlen(l_str); } break; case AGNODE: g_str = agnameof(agraphof((node_t *)obj)); g_len = strlen(g_str); n_str = agnameof((node_t *)obj); n_len = strlen(n_str); tl = ND_label((node_t *)obj); if (tl) { l_str = tl->text; if (str) l_len = strlen(l_str); } break; case AGEDGE: isEdge = 1; g_str = agnameof(agroot(agraphof(agtail(((edge_t *)obj))))); g_len = strlen(g_str); t_str = agnameof(agtail(((edge_t *)obj))); t_len = strlen(t_str); pt = ED_tail_port((edge_t *)obj); if ((tp_str = pt.name)) tp_len = strlen(tp_str); h_str = agnameof(aghead(((edge_t *)obj))); h_len = strlen(h_str); pt = ED_head_port((edge_t *)obj); if ((hp_str = pt.name)) hp_len = strlen(hp_str); h_len = strlen(h_str); tl = ED_label((edge_t *)obj); if (tl) { l_str = tl->text; if (str) l_len = strlen(l_str); } if (agisdirected(agroot(agraphof(agtail(((edge_t*)obj)))))) e_str = "->"; else e_str = "--"; e_len = t_len + (tp_len?tp_len+1:0) + 2 + h_len + (hp_len?hp_len+1:0); break; } /* two passes over str. * * first pass prepares substitution strings and computes * total length for newstring required from malloc. */ for (s = str; (c = *s++);) { if (c == '\\') { switch (c = *s++) { case 'G': newlen += g_len; break; case 'N': newlen += n_len; break; case 'E': newlen += e_len; break; case 'H': newlen += h_len; break; case 'T': newlen += t_len; break; case 'L': newlen += l_len; break; case '\\': if (escBackslash) { newlen += 1; break; } /* Fall through */ default: /* leave other escape sequences unmodified, e.g. \n \l \r */ newlen += 2; } } else { newlen++; } } /* allocate new string */ newstr = gmalloc(newlen + 1); /* second pass over str assembles new string */ for (s = str, p = newstr; (c = *s++);) { if (c == '\\') { switch (c = *s++) { case 'G': for (t = g_str; (*p = *t++); p++); break; case 'N': for (t = n_str; (*p = *t++); p++); break; case 'E': if (isEdge) { for (t = t_str; (*p = *t++); p++); if (tp_len) { *p++ = ':'; for (t = tp_str; (*p = *t++); p++); } for (t = e_str; (*p = *t++); p++); for (t = h_str; (*p = *t++); p++); if (hp_len) { *p++ = ':'; for (t = hp_str; (*p = *t++); p++); } } break; case 'T': for (t = t_str; (*p = *t++); p++); break; case 'H': for (t = h_str; (*p = *t++); p++); break; case 'L': for (t = l_str; (*p = *t++); p++); break; case '\\': if (escBackslash) { *p++ = '\\'; break; } /* Fall through */ default: /* leave other escape sequences unmodified, e.g. \n \l \r */ *p++ = '\\'; *p++ = c; break; } } else { *p++ = c; } } *p++ = '\0'; return newstr; }
/* make_label: * Assume str is freshly allocated for this instance, so it * can be freed in free_label. */ textlabel_t *make_label(void *obj, char *str, int kind, double fontsize, char *fontname, char *fontcolor) { textlabel_t *rv = NEW(textlabel_t); graph_t *g = NULL, *sg = NULL; node_t *n = NULL; edge_t *e = NULL; char *s; switch (agobjkind(obj)) { case AGRAPH: sg = (graph_t*)obj; g = sg->root; break; case AGNODE: n = (node_t*)obj; g = agroot(agraphof(n)); break; case AGEDGE: e = (edge_t*)obj; g = agroot(agraphof(aghead(e))); break; } rv->fontname = fontname; rv->fontcolor = fontcolor; rv->fontsize = fontsize; rv->charset = GD_charset(g); if (kind & LT_RECD) { rv->text = strdup(str); if (kind & LT_HTML) { rv->html = TRUE; } } else if (kind == LT_HTML) { rv->text = strdup(str); rv->html = TRUE; if (make_html_label(obj, rv)) { switch (agobjkind(obj)) { case AGRAPH: agerr(AGPREV, "in label of graph %s\n",agnameof(sg)); break; case AGNODE: agerr(AGPREV, "in label of node %s\n", agnameof(n)); break; case AGEDGE: agerr(AGPREV, "in label of edge %s %s %s\n", agnameof(agtail(e)), agisdirected(g)?"->":"--", agnameof(aghead(e))); break; } } } else { assert(kind == LT_NONE); /* This call just processes the graph object based escape sequences. The formatting escape * sequences (\n, \l, \r) are processed in make_simple_label. That call also replaces \\ with \. */ rv->text = strdup_and_subst_obj0(str, obj, 0); switch (rv->charset) { case CHAR_LATIN1: s = latin1ToUTF8(rv->text); break; default: /* UTF8 */ s = htmlEntityUTF8(rv->text, g); break; } free(rv->text); rv->text = s; make_simple_label(GD_gvc(g), rv); } return rv; }
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); }
int agisundirected(Agraph_t * g) { return NOT(agisdirected(g)); }
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; }
//------------------------------------------------------------------------------ grafo le_grafo(FILE *input) { int i, j; Agnode_t *v; Agedge_t *a; Agraph_t *g_cgraph; // le grafo g_cgraph = agread(input, NULL); if ( !g_cgraph ) return NULL; // Cria grafo grafo g = (grafo) malloc(sizeof(struct grafo)); // pega tipo do grafo g->tipo = agisdirected(g_cgraph); g->peso = SEMPESO; // pega numero de vertices g->n_vertices = agnnodes(g_cgraph); // aloca espaco p/ vetor de vertices g->vertices = (vertice) malloc( (unsigned int)g->n_vertices * sizeof(struct vertice)); if (!g->vertices) return NULL; //Copia nome do grafo g->nome = (char *) malloc(strlen(agnameof(g_cgraph))+1); strcpy(g->nome, agnameof(g_cgraph)); g->matriz_dist = NULL; //aloca matriz g->matriz_adj = (elemento **) malloc((unsigned int)g->n_vertices * sizeof(elemento *) ); // zera matriz for (i=0; i < g->n_vertices; i++){ g->matriz_adj[i] = (elemento *) malloc((unsigned int)g->n_vertices * sizeof(elemento) ); for(j=0; j < g->n_vertices; j++){ g->matriz_adj[i][j].adjacente = 0; } } i = 0; // Copia vertices for (v = agfstnode(g_cgraph ); v; v = agnxtnode(g_cgraph ,v), i++) { // copia nome g->vertices[i].nome = (char *) malloc(strlen(agnameof(v))+1); //g->vertice[i].nome = agnameof(v); strcpy(g->vertices[i].nome, agnameof(v)); // seta next vertice if (i != agnnodes(g_cgraph) - 1) g->vertices[i].next = &g->vertices[i+1]; //set atribute Agnodeinfo_t *p; p = (Agnodeinfo_t*) agbindrec(v,"Agnodeinfo_t",sizeof(Agnodeinfo_t),TRUE); p->ref_v = i; } g->vertices[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(i, v, a, g); } else { for (a=agfstout(g_cgraph,v); a; a=agnxtout(g_cgraph,a)) add_aresta(i, v, a, g); } } free(g_cgraph); return g; }
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; }
static void gv_graph_state(GVJ_t *job, graph_t *g) { #ifndef WITH_CGRAPH int i; #endif int j; Agsym_t *a; gv_argvlist_t *list; list = &(job->selected_obj_type_name); j = 0; if (g == agroot(g)) { if (agisdirected(g)) gv_argvlist_set_item(list, j++, s_digraph); else gv_argvlist_set_item(list, j++, s_graph); } else { gv_argvlist_set_item(list, j++, s_subgraph); } gv_argvlist_set_item(list, j++, agnameof(g)); list->argc = j; list = &(job->selected_obj_attributes); #ifndef WITH_CGRAPH for (i = 0, j = 0; i < dtsize(g->univ->globattr->dict); i++) { a = g->univ->globattr->list[i]; #else a = NULL; while ((a = agnxtattr(g, AGRAPH, a))) { #endif gv_argvlist_set_item(list, j++, a->name); #ifndef WITH_CGRAPH gv_argvlist_set_item(list, j++, agxget(g, a->index)); #else gv_argvlist_set_item(list, j++, agxget(g, a)); #endif gv_argvlist_set_item(list, j++, (char*)GVATTR_STRING); } list->argc = j; a = agfindgraphattr(g, s_href); if (!a) a = agfindgraphattr(g, s_URL); if (a) #ifndef WITH_CGRAPH job->selected_href = strdup_and_subst_obj(agxget(g, a->index), (void*)g); #else job->selected_href = strdup_and_subst_obj(agxget(g, a), (void*)g); #endif } static void gv_node_state(GVJ_t *job, node_t *n) { #ifndef WITH_CGRAPH int i; #endif int j; Agsym_t *a; Agraph_t *g; gv_argvlist_t *list; list = &(job->selected_obj_type_name); j = 0; gv_argvlist_set_item(list, j++, s_node); gv_argvlist_set_item(list, j++, agnameof(n)); list->argc = j; list = &(job->selected_obj_attributes); g = agroot(agraphof(n)); #ifndef WITH_CGRAPH for (i = 0, j = 0; i < dtsize(g->univ->nodeattr->dict); i++) { a = g->univ->nodeattr->list[i]; #else a = NULL; while ((a = agnxtattr(g, AGNODE, a))) { #endif gv_argvlist_set_item(list, j++, a->name); #ifndef WITH_CGRAPH gv_argvlist_set_item(list, j++, agxget(n, a->index)); #else gv_argvlist_set_item(list, j++, agxget(n, a)); #endif } list->argc = j; a = agfindnodeattr(agraphof(n), s_href); if (!a) a = agfindnodeattr(agraphof(n), s_URL); if (a) #ifndef WITH_CGRAPH job->selected_href = strdup_and_subst_obj(agxget(n, a->index), (void*)n); #else job->selected_href = strdup_and_subst_obj(agxget(n, a), (void*)n); #endif } static void gv_edge_state(GVJ_t *job, edge_t *e) { #ifndef WITH_CGRAPH int i; #endif int j; Agsym_t *a; Agraph_t *g; gv_argvlist_t *nlist, *alist; nlist = &(job->selected_obj_type_name); /* only tail, head, and key are strictly identifying properties, * but we commonly alse use edge kind (e.g. "->") and tailport,headport * in edge names */ j = 0; gv_argvlist_set_item(nlist, j++, s_edge); gv_argvlist_set_item(nlist, j++, agnameof(agtail(e))); j++; /* skip tailport slot for now */ gv_argvlist_set_item(nlist, j++, agisdirected(agraphof(agtail(e)))?"->":"--"); gv_argvlist_set_item(nlist, j++, agnameof(aghead(e))); j++; /* skip headport slot for now */ j++; /* skip key slot for now */ nlist->argc = j; alist = &(job->selected_obj_attributes); g = agroot(agraphof(aghead(e))); #ifndef WITH_CGRAPH for (i = 0, j = 0; i < dtsize(g->univ->edgeattr->dict); i++) { a = g->univ->edgeattr->list[i]; #else a = NULL; while ((a = agnxtattr(g, AGEDGE, a))) { #endif /* tailport and headport can be shown as part of the name, but they * are not identifying properties of the edge so we * also list them as modifyable attributes. */ if (strcmp(a->name,s_tailport) == 0) #ifndef WITH_CGRAPH gv_argvlist_set_item(nlist, 2, agxget(e, a->index)); #else gv_argvlist_set_item(nlist, 2, agxget(e, a)); #endif else if (strcmp(a->name,s_headport) == 0) #ifndef WITH_CGRAPH gv_argvlist_set_item(nlist, 5, agxget(e, a->index)); #else gv_argvlist_set_item(nlist, 5, agxget(e, a)); #endif /* key is strictly an identifying property to distinguish multiple * edges between the same node pair. Its non-writable, so * no need to list it as an attribute as well. */ else if (strcmp(a->name,s_key) == 0) { #ifndef WITH_CGRAPH gv_argvlist_set_item(nlist, 6, agxget(e, a->index)); #else gv_argvlist_set_item(nlist, 6, agxget(e, a)); #endif continue; } gv_argvlist_set_item(alist, j++, a->name); #ifndef WITH_CGRAPH gv_argvlist_set_item(alist, j++, agxget(e, a->index)); #else gv_argvlist_set_item(alist, j++, agxget(e, a)); #endif }