예제 #1
0
static int count_all_crossings(nodelist_t * list, Agraph_t * subg)
{
    nodelistitem_t *item;
    edgelist *openEdgeList = init_edgelist();
    Agnode_t *n;
    Agedge_t *e;
    int crossings = 0;
    int order = 1;

    for (n = agfstnode(subg); n; n = agnxtnode(subg, n)) {
	for (e = agfstout(subg, n); e; e = agnxtout(subg, e)) {
	    EDGEORDER(e) = 0;
	}
    }

    for (item = list->first; item; item = item->next) {
	n = item->curr;

	for (e = agfstedge(subg, n); e; e = agnxtedge(subg, e, n)) {
	    if (EDGEORDER(e) > 0) {
		edgelistitem *eitem;
		Agedge_t *ep;

		for (eitem = (edgelistitem *) dtfirst(openEdgeList); eitem;
		     eitem =
		     (edgelistitem *) dtnext(openEdgeList, eitem)) {
		    ep = eitem->edge;
		    if (EDGEORDER(ep) > EDGEORDER(e)) {
			if ((ep->head != n) && (ep->tail != n))
			    crossings++;
		    }
		}
		remove_edge(openEdgeList, e);
	    }
	}

	for (e = agfstedge(subg, n); e; e = agnxtedge(subg, e, n)) {
	    if (EDGEORDER(e) == 0) {
		EDGEORDER(e) = order;
		add_edge(openEdgeList, e);
	    }
	}
	order++;
    }

    free_edgelist(openEdgeList);
    return crossings;
}
예제 #2
0
static void
dfs(Agraph_t * g, Agnode_t * u, bcstate * stp, Agnode_t * parent)
{
    Agnode_t *v;
    Agedge_t *e;
    Agedge_t *ep;
    Agraph_t *sg;

    stp->count++;
    Low(u) = N(u) = stp->count;
    for (e = agfstedge(g, u); e; e = agnxtedge(g, e, u)) {
	if ((v = aghead(e)) == u)
	    v = agtail(e);
	if (v == u)
	    continue;
	if (N(v) == 0) {
	    push(&stp->stk, e);
	    dfs(g, v, stp, u);
	    Low(u) = min(Low(u), Low(v));
	    if (Low(v) >= N(u)) {	/* u is an articulation point */
		Cut(u) = 1;
		sg = mkBlock(g, stp);
		do {
		    ep = pop(&stp->stk);
		    agsubnode(sg, aghead(ep), 1);
		    agsubnode(sg, agtail(ep), 1);
		} while (ep != e);
	    }
	} else if (parent != v) {
	    Low(u) = min(Low(u), N(v));
	    if (N(v) < N(u))
		push(&stp->stk, e);
	}
    }
}
예제 #3
0
파일: grafo.c 프로젝트: gvs11/BCC
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;

}
예제 #4
0
void
dot_sameports (graph_t* g)
/* merge edge ports in G */
{
  node_t *n;
  edge_t *e;
  char   *id;
  same_t same[MAXSAME];
  int    i;

  E_samehead = agfindattr(g->proto->e,"samehead");
  E_sametail = agfindattr(g->proto->e,"sametail");
  if (!(E_samehead || E_sametail)) return;
  for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
    n_same = 0;
    for (e = agfstedge(g,n); e; e = agnxtedge(g,e,n)) {
      if (e->head==n && E_samehead &&
          (id = agxget (e, E_samehead->index))[0])
        sameedge (same, n, e, id);
      else if (e->tail==n && E_sametail &&
               (id = agxget (e, E_sametail->index))[0])
        sameedge (same, n, e, id);
    }
    for (i=0; i<n_same; i++) {
      if (same[i].l.size>1) sameport (n, &same[i].l, same[i].arr_len);
      free_list(same[i].l);
      /* I sure hope I don't need to free the char* id */
    }
  }
}
예제 #5
0
파일: stuff.c 프로젝트: Chaduke/bah.mod
/* degreeKind;
 * Returns degree of n ignoring loops and multiedges.
 * Returns 0, 1 or many (2)
 * For case of 1, returns other endpoint of edge.
 */
static int degreeKind(graph_t * g, node_t * n, node_t ** op)
{
    edge_t *ep;
    int deg = 0;
    node_t *other = NULL;

    for (ep = agfstedge(g, n); ep; ep = agnxtedge(g, ep, n)) {
        if (ep->head == ep->tail)
            continue;		/* ignore loops */
        if (deg == 1) {
            if (((ep->tail == n) && (ep->head == other)) ||	/* ignore multiedge */
                    ((ep->tail == other) && (ep->head == n)))
                continue;
            return 2;
        } else {		/* deg == 0 */
            if (ep->tail == n)
                other = ep->head;
            else
                other = ep->tail;
            *op = other;
            deg++;
        }
    }
    return deg;
}
예제 #6
0
파일: layout.c 프로젝트: ekg/mars
static void adjust_anchors(Agraph_t* g, int* anchors, int k, mat z)
{
    int i, j;
    double* centroid = (double*) malloc(sizeof(double)*z->c);
    for(i = 0; i < k; i++) {
        Agnode_t* n = get_node(anchors[i]);
        Agedge_t* e;
        int degree = 0;
        for(j = 0; j < z->c; j++) {
            centroid[j] = 0;        
        }
        for(e = agfstedge(g,n); e; e = agnxtedge(g,e,n)) {
            int v = (n == aghead(e)) ? getid(agtail(e)) : getid(aghead(e));
            for(j = 0; j < z->c; j++) {
                centroid[j] += z->m[mindex(v,j,z)];         
            }
            degree++;       
        }
        for(j = 0; j < z->c; j++) {
            if(degree != 0)
                centroid[j] /= degree;
            z->m[mindex(anchors[i],j,z)] = centroid[j];
        }
    }
    free(centroid);
}
예제 #7
0
//------------------------------------------------------------------------------
static void guarda_arestas(Agraph_t *g, Agnode_t *v) {

  for (Agedge_t *a=agfstedge(g,v); a; a=agnxtedge(g,a,v))

    if ( ! busca_aresta(a) )

  	  insere_lista(a, lista_arestas);
}
예제 #8
0
/* remove_pair_edges:
 * Create layout skeleton of ing.
 * Why is returned graph connected?
 */
static Agraph_t *remove_pair_edges(Agraph_t * ing)
{
    int counter = 0;
    int nodeCount;
    Agraph_t *outg;
    Agraph_t *g;
    deglist_t *dl;
    Agnode_t *currnode, *adjNode;
    Agedge_t *e;

    outg = clone_graph(ing, &g);
    nodeCount = agnnodes(g);
    dl = getList(g);

    while (counter < (nodeCount - 3)) {
	currnode = firstDeglist(dl);

	/* Remove all adjacent nodes since they have to be reinserted */
	for (e = agfstedge(g, currnode); e; e = agnxtedge(g, e, currnode)) {
	    adjNode = e->head;
	    if (currnode == adjNode)
		adjNode = e->tail;
	    removeDeglist(dl, adjNode);
	}

	find_pair_edges(g, currnode, outg);

	for (e = agfstedge(g, currnode); e; e = agnxtedge(g, e, currnode)) {
	    adjNode = e->head;
	    if (currnode == adjNode)
		adjNode = e->tail;

	    DEGREE(adjNode)--;
	    insertDeglist(dl, adjNode);
	}

	agdelete(g, currnode);

	counter++;
    }

    agclose(g);
    freeDeglist(dl);
    return outg;
}
예제 #9
0
파일: blockpath.c 프로젝트: aosm/graphviz
/* find_longest_path:
 * Find and return longest path in tree.
 */
static nodelist_t*
find_longest_path(Agraph_t* tree)
{
	Agnode_t* n;
	Agedge_t* e;
	Agnode_t* common = 0;
	nodelist_t* path;
	nodelist_t* endPath;
	int maxlength = 0;
	int length;

	if (agnnodes(tree) == 1) {
		path = mkNodelist();
		n = agfstnode(tree);
		appendNodelist(path, NULL, n);
		SET_ONPATH(n);
		return path;
	}

	for(n = agfstnode(tree); n; n = agnxtnode(tree, n)) {
		int count = 0;
		for(e = agfstedge(tree, n); e; e = agnxtedge(tree, e, n)) {
			count++;	
		}
		if(count == 1)
			measure_distance(n, n, 0, NULL);
	}

	/* find the branch node rooted at the longest path */
	for(n = agfstnode(tree); n; n = agnxtnode(tree, n)) {
		length = DISTONE(n) + DISTTWO(n);
		if(length > maxlength) {
			common = n;
			maxlength = length;
		}
	}

	path = mkNodelist();
	for (n = LEAFONE(common); n != common; n = TPARENT(n)) {
		appendNodelist(path, NULL, n);
		SET_ONPATH(n);
	}
	appendNodelist(path, NULL, common);
	SET_ONPATH(common);
	
	if (DISTTWO(common)) { /* 2nd path might be empty */
		endPath = mkNodelist();
		for (n = LEAFTWO(common); n != common; n = TPARENT(n)) {
			appendNodelist(endPath, NULL, n);
			SET_ONPATH(n);
		}
		reverseAppend(path, endPath);
	}
	
	return path;
}
예제 #10
0
static void flat_edges(Agraph_t *clust)
{
#ifdef NOTDEF
	for (n = agfstnode(clust); n; n = agnxtnode(clust)) {
		for (e = agfstedge(root,n); e; e = agnxtedge(root,e,n)) {
		}
	}
	ordered_edges();
#endif
}
예제 #11
0
/* 
 * attach and install edges between clusters.
 * essentially, class2() for interclust edges.
 */
void interclexp(graph_t* subg)
{
	graph_t		*g;
	node_t		*n;
	edge_t		*e,*prev;

	g = subg->root;
	for (n = agfstnode(subg); n; n = agnxtnode(subg,n)) {

		/* N.B. n may be in a sub-cluster of subg */
		prev = NULL;
		for (e = agfstedge(subg->root,n); e; e = agnxtedge(subg->root,e,n)) {
			if (agcontains(subg,e)) continue;

			/* short/flat multi edges */
			if (mergeable(prev,e)) {
					if (e->tail->u.rank == e->head->u.rank) e->u.to_virt = prev;
					else e->u.to_virt = NULL;
					if (prev->u.to_virt == NULL) continue;	/* internal edge */
					merge_chain(subg,e,prev->u.to_virt,FALSE);
					safe_other_edge(e);
					continue;
			}

				/* flat edges */
			if (e->tail->u.rank == e->head->u.rank) {
				if (find_flat_edge(e->tail,e->head) == NULL) {
					flat_edge(g,e); prev = e;
				}
				else prev = NULL;
				continue;
			}

			assert (e->u.to_virt != NULL);

				/* forward edges */
			if (e->head->u.rank > e->tail->u.rank) {
				make_interclust_chain(g,e->tail,e->head,e);
				prev = e;
				continue;
			}

				/* backward edges */
			else {
/*
I think that make_interclust_chain should create call other_edge(e) anyway 
				if (agcontains(subg,e->tail)
					&& agfindedge(subg->root,e->head,e->tail)) other_edge(e);
*/
				make_interclust_chain(g,e->head,e->tail,e);
				prev = e;
			}
		}
	}
}
예제 #12
0
static void deleteNodeEdges(gctx_t *gctx, Agraph_t *g, Agnode_t *n)
{
    Agedge_t *e, *e1;

    e = agfstedge(g, n);
    while (e) {
	e1 = agnxtedge(g, e, n);
	deleteEdge(gctx, g, e);
	e = e1;
    }
}
예제 #13
0
//------------------------------------------------------------------------------
long int *obter_matriz_adjacencia(Agraph_t *g, vertice lista_vertices, int grafo_ponderado, int grafo_direcionado, unsigned int n_vertices) {
  Agedge_t *a;
  Agnode_t *v;
  long int *matriz = NULL;
  char *peso;
  char peso_string[] = "peso";
  unsigned i;
  int cauda_indice, cabeca_indice;

  if(n_vertices > 0) {
    /* Aloca a quantidade de memória necessária para armazenar todas as arestas */
    matriz = (long int *) malloc(sizeof(long int) * n_vertices * n_vertices);

    if(matriz != NULL) {
      /* Inicializa a matriz */
      for(i = 0; i < n_vertices * n_vertices; ++i) {
        matriz[i] = 0;
      }

      /* Percorre todas as arestas do grafo */
      for(v = agfstnode(g); v != NULL; v = agnxtnode(g, v)) {
        for(a = agfstedge(g, v); a != NULL; a = agnxtedge(g, a, v)) {
          /* Obtêm os vértices de origem e destino da aresta */
          cauda_indice = encontra_vertice(lista_vertices, n_vertices, agnameof(agtail(a)));
          cabeca_indice = encontra_vertice(lista_vertices, n_vertices, agnameof(aghead(a)));

          /* Caso não sejam encontrados, retorna com um erro */
          if(cauda_indice == -1 || cabeca_indice == -1) {
            free(matriz);
            return NULL;
          }

          /* Se o grafo é ponderado, armazena o valor do peso (se existir) na matriz,
             caso contrário armazena o valor 1 */
          if(grafo_ponderado == 1) {
            peso = agget(a, peso_string);
            matriz[cauda_indice * (int) n_vertices + cabeca_indice] = (peso != NULL && *peso != '\0') ? atol(peso) : 0;
          } else {
            matriz[cauda_indice * (int) n_vertices + cabeca_indice] = 1;
          }

          /* Se o grafo não é direcionado, então M[i,j] = M[j,i] */
          if(grafo_direcionado != 1) {
            matriz[cabeca_indice * (int) n_vertices + cauda_indice] = matriz[cauda_indice * (int) n_vertices + cabeca_indice];
          }
        }
      }
    }
  }

  return matriz;
}
예제 #14
0
파일: gc.c 프로젝트: aosm/graphviz
static void 
cc_dfs(Agraph_t* g, Agnode_t* n)
{
    Agedge_t*    e;
    Agnode_t*    nxt;

    ND_dfs_mark(n) = 1;
    for (e = agfstedge(g, n); e ; e = agnxtedge(g, e, n)) {
        if (n == e->tail) nxt = e->head;
        else nxt = e->tail;
        if (ND_dfs_mark(nxt) == 0) cc_dfs(g,nxt);
    }
}
예제 #15
0
static v_data *makeGraph(Agraph_t* gg, int *nedges)
{
    int i;
    int ne = agnedges(gg);
    int nv = agnnodes(gg);
    v_data *graph = N_NEW(nv, v_data);
    int *edges = N_NEW(2 * ne + nv, int);	/* reserve space for self loops */
    float *ewgts = N_NEW(2 * ne + nv, float);
    Agnode_t *np;
    Agedge_t *ep;
    Agraph_t *g = NULL;
    int i_nedges;
    ne = 0;
    i=0;
//    for (i = 0; i < nv; i++) {
    for (np = agfstnode(gg); np; np = agnxtnode(gg, np)) 
    {
	graph[i].edges = edges++;	/* reserve space for the self loop */
	graph[i].ewgts = ewgts++;
#ifdef STYLES
	graph[i].styles = NULL;
#endif
	i_nedges = 1;		/* one for the self */

	if (!g)
	    g = agraphof(np);
	for (ep = agfstedge(g, np); ep; ep = agnxtedge(g, ep, np)) 
	{
	    Agnode_t *vp;
	    Agnode_t *tp = agtail(ep);
	    Agnode_t *hp = aghead(ep);
	    assert(hp != tp);
	    /* FIX: handle multiedges */
	    vp = (tp == np ? hp : tp);
	    ne++;
	    i_nedges++;
//	    *edges++ = ((temp_node_record *) AGDATA(vp))->TVref;
	    *edges++ = ND_TVref(vp);
	    *ewgts++ = 1;

	}

	graph[i].nedges = i_nedges;
	graph[i].edges[0] = i;
	graph[i].ewgts[0] = 1 - i_nedges;
	i++;
    }
    ne /= 2;			/* each edge counted twice */
    *nedges = ne;
    return graph;
}
예제 #16
0
/* constrainY:
 * See constrainX.
 */
static void constrainY(graph_t* g, nitem* nlist, int nnodes, intersectfn ifn,
                       int ortho)
{
    Dt_t *list = dtopen(&constr, Dtobag);
    nitem *p = nlist;
    graph_t *cg;
    int i;

    for (i = 0; i < nnodes; i++) {
	p->val = p->pos.y;
	dtinsert(list, p);
	p++;
    }
    if (ortho)
	cg = mkConstraintG(g, list, ifn, distY);
    else
	cg = mkNConstraintG(g, list, ifn, distY);
    rank(cg, 2, INT_MAX);
#ifdef DEBUG
    {
	Agsym_t *mlsym = agedgeattr(cg, "minlen", "");
	Agsym_t *rksym = agnodeattr(cg, "rank", "");
	char buf[100];
	node_t *n;
	edge_t *e;
	for (n = agfstnode(cg); n; n = agnxtnode(cg, n)) {
	    sprintf(buf, "%d", ND_rank(n));
	    agxset(n, rksym->index, buf);
	    for (e = agfstedge(cg, n); e; e = agnxtedge(cg, e, n)) {
		sprintf(buf, "%d", ED_minlen(e));
		agxset(e, mlsym->index, buf);
	    }
	}
    }
#endif

    p = nlist;
    for (i = 0; i < nnodes; i++) {
	int newpos, oldpos, delta;
	oldpos = p->pos.y;
	newpos = ND_rank(p->cnode);
	delta = newpos - oldpos;
	p->pos.y = newpos;
	p->bb.LL.y += delta;
	p->bb.UR.y += delta;
	p++;
    }

    closeGraph(cg);
    dtclose(list);
}
예제 #17
0
파일: fdpinit.c 프로젝트: ekoontz/graphviz
void fdp_cleanup(graph_t * g)
{
    node_t *n;
    edge_t *e;

    n = agfstnode(g);
    free(ND_alg(n));
    for (; n; n = agnxtnode(g, n)) {
	for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
	    gv_cleanup_edge(e);
	}
	gv_cleanup_node(n);
    }
    fdp_cleanup_graph(g);
}
예제 #18
0
파일: sccmap.c 프로젝트: aosm/graphviz
static int 
label(Agnode_t *n, int nodecnt, int* edgecnt)
{
  Agedge_t    *e;

  setval(n,1);
  nodecnt++;
  for (e = agfstedge(n); e; e = agnxtedge(e,n)) {
    (*edgecnt) += 1;
    if (e->node == n) e = agopp(e);
    if (!getval(e->node))
      nodecnt = label(e->node,nodecnt,edgecnt);
  }
  return nodecnt;
}
예제 #19
0
void dijkstra(Dict_t * Q, Agraph_t * G, Agnode_t * n)
{
    Agnode_t *u;
    Agedge_t *e;

    pre(G);
    setdist(n, 1);
    dtinsert(Q, n);
    while ((u = extract_min(Q))) {
	for (e = agfstedge(u); e; e = agnxtedge(e, u)) {
	    update(Q, e->node, u, getlength(e));
	}
    }
    post(G);
}
예제 #20
0
파일: actions.c 프로젝트: ellert/graphviz
static void cc_dfs(Agraph_t* g, Agraph_t * comp, Agnode_t * n)
{
    Agedge_t *e;
    Agnode_t *other;

    CCMARK(n);
    agidnode(comp, AGID(n), 1);
    for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
	if (agtail(e) == n)
	    other = aghead(e);
	else
	    other = agtail(e);
	if (!CCMARKED(other))
	    cc_dfs(g, comp, other);
    }
}
예제 #21
0
static v_data *makeGraph(topview * tv, int *nedges)
{
    int i;
    int ne = tv->Edgecount;	/* upper bound */
    int nv = tv->Nodecount;
    v_data *graph = N_NEW(nv, v_data);
    int *edges = N_NEW(2 * ne + nv, int);  /* reserve space for self loops */
    float *ewgts = N_NEW(2 * ne + nv, float);
    Agnode_t *np;
    Agedge_t *ep;
    Agraph_t *g = NULL;
    int i_nedges;

    ne = 0;
    for (i = 0; i < nv; i++) {
	graph[i].edges = edges++;	/* reserve space for the self loop */
	graph[i].ewgts = ewgts++;
#ifdef STYLES
	graph[i].styles = NULL;
#endif
	i_nedges = 1;		/* one for the self */

	np = tv->Nodes[i].Node;
	if (!g)
	    g = agraphof(np);
	for (ep = agfstedge(g, np); ep; ep = agnxtedge(g, ep, np)) {
	    Agnode_t *vp;
	    Agnode_t *tp = agtail(ep);
	    Agnode_t *hp = aghead(ep);
	    assert(hp != tp);
	    /* FIX: handle multiedges */
	    vp = (tp == np ? hp : tp);
	    ne++;
	    i_nedges++;
	    *edges++ = OD_TVRef(vp);
	    *ewgts++ = 1;
	}

	graph[i].nedges = i_nedges;
	graph[i].edges[0] = i;
	graph[i].ewgts[0] = 1 - i_nedges;
    }
    ne /= 2;			/* each edge counted twice */
    *nedges = ne;
    return graph;
}
예제 #22
0
파일: comp.c 프로젝트: hhoeflin/Rgraphviz
static void dfs(Agraph_t * g, Agnode_t * n, Agraph_t * out, char *marks)
{
    Agedge_t *e;
    Agnode_t *other;

    MARK(n) = 1;
#ifndef WITH_CGRAPH
    aginsert(out, n);
#else /* WITH_CGRAPH */
    agsubnode(out,n,1);
#endif /* WITH_CGRAPH */
    for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
	if ((other = agtail(e)) == n)
	    other = aghead(e);
	if (!MARK(other))
	    dfs(g, other, out, marks);
    }
}
예제 #23
0
/* dfs:
 * Simple depth first search, adding traversed edges to tree.
 */
static void dfs(Agraph_t * g, Agnode_t * n, Agraph_t * tree)
{
    Agedge_t *e;
    Agnode_t *neighbor;

    SET_VISITED(n);
    for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
	neighbor = e->head;
	if (neighbor == n)
	    neighbor = e->tail;

	if (!VISITED(neighbor)) {
	    /* add the edge to the dfs tree */
	    aginsert(tree, e);
	    TPARENT(neighbor) = n;
	    dfs(g, neighbor, tree);
	}
    }
}
예제 #24
0
파일: gr_node.c 프로젝트: hleuwer/luagraph
/*-------------------------------------------------------------------------*\
 * Write info about a node to stdout.
 * Example:
 * n:info()
\*-------------------------------------------------------------------------*/
static int gr_info(lua_State *L)
{
  Agraph_t  *g;
  gr_node_t *ud = tonode(L, 1, STRICT);
  Agedge_t *se;
  Agsym_t *sym;
  
  g = agraphof(ud->n);
  printf("INFO NODE '%s' '%s' id=%lu seq=%d\n", agnameof(ud->n), ud->name, (unsigned long) AGID(ud->n), AGSEQ(ud->n));
  printf("  ptr: %p\n", ud->n);
  printf("  Symbols:\n");
  se = agfstout(g, ud->n);
  sym=0;
  while ((sym = agnxtattr(g,AGNODE,sym))!=NULL)
         printf("    %s = '%s'\n",sym->name,sym->defval);
#if 0
  printf("  Out edges: d-out=%d u-out=%d\n", agdegree(g, ud->n, 0, 1), agcountuniqedges(g, ud->n, 0, 1));
#endif
  while (se) {
    printf("    name: '%s', head: '%s', tail: '%s' id=%lud, seq=%d %p\n",
           agnameof(se), agnameof(aghead(se)), agnameof(agtail(se)), (unsigned long) AGID(se), AGSEQ(se), (void*)se);
    se = agnxtout(g, se);
  }
#if 0
  printf("  In edges: d-in=%d u-in=%d\n", agdegree(g, ud->n, 1, 0), agcountuniqedges(g, ud->n, 1, 0));
#endif
  se = agfstin(g, ud->n);
  while (se) {
    printf("    name: '%s', head: '%s', tail: '%s' îd=%lu seq=%d %p\n",
           agnameof(se), agnameof(aghead(se)), agnameof(agtail(se)), (unsigned long) AGID(se), AGSEQ(se), (void*)se);
    se = agnxtin(g, se);
  }
#if 0
  printf("  Edges: d-io=%d u-io=%d\n", agdegree(g, ud->n, 1, 1), agcountuniqedges(g, ud->n, 1, 1));
#endif  
  se = agfstedge(g, ud->n);
  while (se) {
    printf("    name: '%s', head: '%s', tail: '%s' id=%lud seq=%d %p\n",
           agnameof(se), agnameof(aghead(se)), agnameof(agtail(se)), (unsigned long) AGID(se), AGSEQ(se), (void*)se);
    se = agnxtedge(g, se, ud->n);
  }
  return 0;
}
예제 #25
0
파일: gr_node.c 프로젝트: LuaDist/luagraph
/*-------------------------------------------------------------------------*\
 * Method: n.delete(self)
 * Delete a node. All associated edges are deleted as well.
 * Returns non-nil on success.
 * Example:
 * rv, err = n:delete(h)
\*-------------------------------------------------------------------------*/
static int gr_delete(lua_State *L)
{
  Agraph_t *g;
  gr_node_t *ud = tonode(L, 1, NONSTRICT);
  if (ud->n != NULL){
    /* Delete all associated edges with tail on this node */
    Agedge_t *se, *ne;
    int ix;
    g = ud->n->graph;
    se = agfstedge(g, ud->n);
    while (se){
      ne = agnxtedge(g, se, ud->n);
      ix = get_object(L, se);         /* ud, se */
      if (!(lua_isnil(L, -ix))){
	TRACE("n:delete(): closing subedge: ud=%p 'edge@%d' id=0x%0x e=%p\n", 
	       (void *) lua_touserdata(L, -ix), AGID(se), AGID(se), (void *)se);
	lua_pushcfunction(L, gr_delete_edge); /* ud, se, func */
	lua_pushvalue(L, -2);                 /* ud, se, func, se */
	lua_call(L, 1, LUA_MULTRET);          /* ud, se */
	lua_pop(L, 1);                        /* ud */
      } else {
	lua_pop(L, 2);                        /* ud */
      }
      se = ne;
    }
    TRACE("n:delete(): ud=%p '%s' id=0x%0x \n", 
	  (void *) ud, agnameof(ud->n), AGID(ud->n));
    del_object(L, ud->n);
    agdelete(g, ud->n);
    ud->n = NULL;
    if (ud->name){
      free(ud->name);
      ud->name = NULL;
    }
  } else {
    TRACE("n:delete(): ud=%p already closed\n", (void *)ud);
  }
  lua_pushnumber(L, 0);
  return 1;
}
예제 #26
0
파일: gr_node.c 프로젝트: hleuwer/luagraph
/*-------------------------------------------------------------------------*\
 * Method: e = nextedge(self, prev)
 * Retrieves next edge of a node.
 * Returns the next edge of the given node. With nil as prev the first
 * edge is returned. 
 * Example:
 * first = n:nextedge(nil)
 * second = n:nextedge(first)
 * third = n:nextedge(second)
\*-------------------------------------------------------------------------*/
static int gr_nextedge(lua_State *L)
{
  int rv;
  char sbuf[32];
  Agraph_t *g;
  Agedge_t *e;
  gr_edge_t *ud_e;
  gr_node_t *ud_n = tonode(L, 1, STRICT);
  g = agroot(ud_n->n);

  if (lua_isnil(L, 2)){
    e = agfstedge(g, ud_n->n);
  } else {
    ud_e = toedge(L, 2, STRICT);
    e = agnxtedge(g, ud_e->e, ud_n->n);
  }
  if (!e){
    /* no more edges */
    lua_pushnil(L);
    return 1;
  } else {
    /* Check whether userdata exists .. */
    rv = get_object(L, e);
    if (rv == 1){
      /* .. yes: return it */
      return rv;
    } else {
      /* .. no: create it */
      lua_pop(L, rv);
      ud_e = lua_newuserdata(L, sizeof(gr_edge_t)); 
      ud_e->e = e;
      sprintf(sbuf, "edge@%lu", (unsigned long) AGID(e));
      ud_e->name = strdup(sbuf);
      ud_e->type = AGEDGE;
      ud_e->status = ALIVE;
      set_object(L, e);
      return new_edge(L);
    }
  }
}
예제 #27
0
/* reduce:
 * Attempt to reduce edge crossings by moving nodes.
 * Original crossing count is in cnt; final count is returned there.
 * list is the original list; return the best list found.
 */
static nodelist_t *reduce(nodelist_t * list, Agraph_t * subg, int *cnt)
{
    Agnode_t *curnode;
    Agedge_t *e;
    Agnode_t *neighbor;
    nodelist_t *listCopy;
    int crossings, j, newCrossings;

    crossings = *cnt;
    for (curnode = agfstnode(subg); curnode;
	 curnode = agnxtnode(subg, curnode)) {
	/*  move curnode next to its neighbors */
	for (e = agfstedge(subg, curnode); e;
	     e = agnxtedge(subg, e, curnode)) {
	    neighbor = e->tail;
	    if (neighbor == curnode)
		neighbor = e->head;

	    for (j = 0; j < 2; j++) {
		listCopy = cloneNodelist(list);
		insertNodelist(list, curnode, neighbor, j);
		newCrossings = count_all_crossings(list, subg);
		if (newCrossings < crossings) {
		    crossings = newCrossings;
		    freeNodelist(listCopy);
		    if (crossings == 0) {
			*cnt = 0;
			return list;
		    }
		} else {
		    freeNodelist(list);
		    list = listCopy;
		}
	    }
	}
    }
    *cnt = crossings;
    return list;
}
예제 #28
0
파일: block.c 프로젝트: Chaduke/bah.mod
void printBlocklist(blocklist_t * snl)
{
    block_t *bp;
    for (bp = snl->first; bp; bp = bp->next) {
	Agnode_t *n;
	char *p;
	Agraph_t *g = bp->sub_graph;
	fprintf(stderr, "block=%s\n", g->name);
	for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
	    Agedge_t *e;
	    if (PARENT(n))
		p = PARENT(n)->name;
	    else
		p = "<nil>";
	    fprintf(stderr, "  %s (%d %s)\n", n->name, VAL(n), p);
	    for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
		fprintf(stderr, "    %s--%s\n", e->tail->name,
			e->head->name);
	    }
	}
    }
}
예제 #29
0
int circuit_model(graph_t * g, int nG)
{
    double **Gm;
    double **Gm_inv;
    int rv;
    long i, j;
    node_t *v;
    edge_t *e;

    Gm = new_array(nG, nG, 0.0);
    Gm_inv = new_array(nG, nG, 0.0);

    /* set non-diagonal entries */
    for (v = agfstnode(g); v; v = agnxtnode(g, v)) {
	for (e = agfstedge(g, v); e; e = agnxtedge(g, e, v)) {
	    i = AGID(agtail(e));
	    j = AGID(aghead(e));
	    if (i == j)
		continue;
	    /* conductance is 1/resistance */
	    Gm[i][j] = Gm[j][i] = -1.0 / ED_dist(e);	/* negate */
	}
    }

    rv = solveCircuit(nG, Gm, Gm_inv);

    if (rv)
	for (i = 0; i < nG; i++) {
	    for (j = 0; j < nG; j++) {
		GD_dist(g)[i][j] =
		    Gm_inv[i][i] + Gm_inv[j][j] - 2.0 * Gm_inv[i][j];
	    }
	}
    free_array(Gm);
    free_array(Gm_inv);
    return rv;
}
예제 #30
0
파일: blocktree.c 프로젝트: Chaduke/bah.mod
/* findUnvisited:
 * Look for unvisited node n in visited block (i.e., some nodes in
 * the block have been visited) with neighbor not in block. Note
 * that therefore neighbor is unvisited. Set neighbor's parent to n
 * and return neighbor.
 * Guaranteed blp is non-empty.
 * 
 */
static Agnode_t *findUnvisited(blocklist_t * blp)
{
    Agnode_t *retn = NULL;
  FIX:finish Agnode_t * n;
    Agnode_t *newn;
    graph_t *clust_subg;
    edge_t *e;
    block_t *bp;
    block_t *prev = NULL;

    for (bp = blp->first; prev != blp->last; bp = bp->next) {
	prev = bp;
	clust = bp->sub_graph;

	if (DONE(bp))
	    continue;
	if (PARTIAL(bp)) {
	    for (n = agfstnode(clust); n; n = agnxtnode(clust, n)) {
		if (!VISITED(n)) {
		    for (e = agfstedge(g, n); e; e = agnxtedge(g, e, n)) {
			newn = e->head;
			if (newn == n)
			    newn = e->tail;
			if ((BLOCK(newn) != bp)) {
			    retn = newn;
			    return;
			}
		    }
		    /* mark n visited */
		}
	    }
	    /* mark bp done */
	} else {
	}
    }
    return retn;
}