Edge GRAPHmaxFlow(Graph G){

    int i,j;
    Edge e;
    e=EDGE(0,0,0);
    for(i=0;i<G->V;i++){
        for(j=0;j<G->V;j++){
            if(G->adj[i][j]>e.cost){
            e=EDGE(i,j,G->adj[i][j]);
        }}}
    return e;
}
Edge* EDGEget(Graph G, int *n){

    int i,j,cont=0,k=0;
    Edge *e,a;

    for(i=0;i<G->V;i++){
        for(j=0;j<G->V;j++){
            if(G->adj[i][j]!=0)
                cont++;
        }}
    *n=cont;

    e=malloc(cont*sizeof(Edge));

    for(i=0;i<G->V;i++){
        for(j=0;j<G->V;j++){
            if(G->adj[i][j]!=0){
                a=EDGE(i,j,G->adj[i][j]);
                e[k]=a;
                k++;
            }
        }}
    return e;

}
Exemple #3
0
Graph generate_network (char *filename)
{
    FILE *finn;
    int n;
    int v, w;
    double weight;
    Edge e;
    Graph G = malloc(sizeof(Graph));

    finn = fopen(filename, "r");
    if (finn == NULL)
    {
        fprintf(stderr, "Error in opening file %s.\n", filename);
        exit(EXIT_FAILURE);
    }

    fscanf (finn, "%d", &n);

    G = GRAPHinit(n);

    while ( (fscanf(finn, "%d-%d %lf", &v, &w, &weight)) > 0 )
    {
        e = EDGE(v, w, weight);
        GRAPHinsertE(G, e);
    }

    fclose(finn);
    return G;

}
Exemple #4
0
void dfsR(Graph G, Edge e)
{
    link t; int v, w = e.w; Edge x;
    if (e.v != e.w)
        printf("edge (%d, %d) is tree \n", e.v, e.w) ;
    st[e.w] = e.v;
    pre[w] = time++;
    for (t = G->adj[w]; t != NULL; t = t->next)
      if (pre[t->v] == -1)
        dfsR(G, EDGE(w, t->v));
      else {
        v = t->v;
        x = EDGE(w, v);
        if (pre[w] < pre[v])
            printf("edge (%d, %d) is back \n", x.v, x.w) ;
      }
    post[w] = time++;
}
/// Preenche o vetor de Edges @a com todas as arestas existentes no grafo.
/// @a: vetor de arestas.
/// @G: grafo de busca.
/// @return: número de arestas existentes.
int GRAPHedges( Edge a[], Graph *G )
{
    int v, w, E = 0;
    for( v = 0; v < G->V; v++)
        for( w = v+1; w < G->V; w++)
            if( G->adj[v][w] == 1 )
                a[E++] = EDGE( v, w );
    return E;
}
Exemple #6
0
edge_set transform_figure(edge_set es, float A[4][4]) {
    size_t s = es.size();
    edge_set to_return(s);

    for (int i = 0 ; i < s ; i++) {
        to_return[i] = EDGE(transform(es.at(i).first, A), transform(es.at(i).second, A));
    }
    return to_return;
}
Exemple #7
0
// edges with probability p
Graph GRAPHrand(Graph G, int V, int E)
{
    int i, j;
    double p = 2.0 * E / (V * (V-1));
    for ( i = 0; i < V; i++)
        for ( j = i+1; j < V; j++)
            if (rand() < p * RAND_MAX)
                GRAPHinsertE(G, EDGE(i, j));
    return G;
}
Exemple #8
0
Graph GRAPHrand(int V, int E)
  { int i, j;
    double p = 2.0*E/V/(V-1);
    Graph G = GRAPHinit(V);
    for (i = 0; i < V; i++)
      for (j = 0; j < i; j++)
        if (rand() < p*RAND_MAX)
          GRAPHinsertE(G, EDGE(i, j));
    return G;
  }
Exemple #9
0
int   GRAPHedges(Graph G, Edge a[])
{
    int v, E = 0;
    link t;
    for (v=0; v < G->V; v++)
        for (t=G->adj[v]; t != NULL; t = t->next)
            if (v < t->v)
                a[E++] = EDGE(v, t->v);
    return E;
}
int igraph_i_create_start(igraph_vector_t *res, igraph_vector_t *el, igraph_vector_t *index, 
			  igraph_integer_t nodes) {
  
# define EDGE(i) (VECTOR(*el)[ (long int) VECTOR(*index)[(i)] ])
  
  long int no_of_nodes;
  long int no_of_edges;
  long int i, j, idx;
  
  no_of_nodes=nodes;
  no_of_edges=igraph_vector_size(el);
  
  /* result */
  
  IGRAPH_CHECK(igraph_vector_resize(res, nodes+1));
  
  /* create the index */

  if (igraph_vector_size(el)==0) {
    /* empty graph */
    igraph_vector_null(res);
  } else {
    idx=-1;
    for (i=0; i<=EDGE(0); i++) {
      idx++; VECTOR(*res)[idx]=0;
    }
    for (i=1; i<no_of_edges; i++) {
      long int n=EDGE(i) - EDGE((long int)VECTOR(*res)[idx]);
      for (j=0; j<n; j++) {
	idx++; VECTOR(*res)[idx]=i;
      }
    }
    j=EDGE((long int)VECTOR(*res)[idx]);
    for (i=0; i<no_of_nodes-j; i++) {
      idx++; VECTOR(*res)[idx]=no_of_edges;
    }
  }

  /* clean */

# undef EDGE
  return 0;
}
Exemple #11
0
int  path(Graph g, int v)
{
    int w;
    for( ; g->adj[v] != NULL; v=w){
        STACKpush(v);
        w = g->adj[v]->v;
        GRAPHremoveE(g,EDGE(v,w));
    }
    return v;
}
Exemple #12
0
static void
findstats(Pos p, Ori o)
{
	/* Recalculate cross assert and score total at 'p'
	 */
	Pos	left, right;
	Word lword, rword;
	Node n;
	Edge e;
	int	s;

	lword.n = rword.n = 0;
	if(EDGE(p))
		return;

	/* find word to the left */
	s = 0;
	for(left=PREV(p,o); HASLETTER(left); left = PREV(left,o))
		;
	left = NEXT(left,o);
	while (HASLETTER(left)) {
		lword.c[lword.n++] = LETTER(left);
		s += SCORE(left);
		left = NEXT(left,o);
	}
	/* find word to the right */
	for(right=NEXT(p,o); HASLETTER(right); right = NEXT(right,o)) {
		rword.c[rword.n++] = LETTER(right);
		s += SCORE(right);
	}
	if(DBG) {
		wordprint(&lword);
		print("X");
		wordprint(&rword);
		print(" [%d] ", s);
	}

	SIDE(p,o) = s;
	ISANCHOR(p) = true;

	/* calculate cross asserts */
	CROSS(p,o) = 0;
	n = traverse(root, &lword, 0);
	assert(n>=0);
	if(n>0)
		do {
			e = dict[n++];
			if ( (rword.n && isword(NODE(e), &rword)) || 
				 (!rword.n && TERM(e)) ) {
				CROSS(p,o) |= 1 << LET(e);
				DPRINT("%c, ", LET(e)+'a');
			}
		} while (!(LAST(e)));
	DPRINT("\n");
}
Exemple #13
0
edge_set translate_figure(edge_set es, float dx, float dy, float dz) {
    float A[4][4];
    generate_translation_matrix(A, dx, dy, dz);

    size_t s = es.size();
    edge_set to_return(s);

    for (int i = 0 ; i < s ; i++) {
        to_return[i] = EDGE(transform(es.at(i).first, A), transform(es.at(i).second, A));
    }
    return to_return;
}
Graph graphScan(char *file){
    int v,w;
    int V;
    FILE *in = fopen(file, "r");
    fscanf(in, "%d",&V);
    Graph g = GRAPHinit(V);
    while(fscanf(in,"%d %d",&v,&w) == 2){
        GRAPHinsertE(g,EDGE(v,w));
    }
    fclose(in);
    return g;
}
Exemple #15
0
int GRAPHedges(Edge a[], Graph g)
{
    int v, e=0;
    link t;
    for (v = 0; v < g->v; v++) {
        for(t = g->adj[v]; t != NULL; t = t->next)
            if(v < t->v)
                a[e++] = EDGE(v,t->v);
    }
    retrun e;

}
Exemple #16
0
void  GRAPHbridge(Graph G)
{
    int v;
    time = 0, bcnt =0;
    for (v=0; v < G->V; v++)
      pre[v] = -1;
    for (v=0; v < G->V; v++)
      if (pre[v]== -1)
        bridgeR(G, EDGE(v, v));
    if (bcnt == 0)
      printf("No bridge found!\n");
}
Exemple #17
0
int GRAPHedges (Edge edges[], Graph g) {
    int v, E = 0; 
    vlink t;  

    for (v = 0; v < g->V; v++) {
        for (t = g->adj[v]; t != NULL; t = t->next) {
            if (v < t->v) {
                edges[E++] = EDGE(v, t->v); 
            }
        }
    }
    return E;
}
Exemple #18
0
edge_set rotate_figure(edge_set es, int axis, float angle) {
    float A[4][4];
    generate_rotation_matrix(A, axis, angle);

    size_t s = es.size();
    edge_set to_return(s);
    
    for (int i = 0 ; i < s ; i++) {
        to_return[i] = EDGE(transform(es.at(i).first, A), transform(es.at(i).second, A));
    }

    return to_return;
}
Exemple #19
0
Fichier : graph.c Projet : piki/pip
void gtk_graph_clear(GtkGraph *graph) {
	int i;

	g_return_if_fail(graph);
	g_return_if_fail(GTK_IS_GRAPH(graph));

	for (i=0; i<graph->nodes->len; i++) {
		if (NODE(graph, i)->label) g_free(NODE(graph, i)->label);
		g_free(NODE(graph, i));
	}
	for (i=0; i<graph->edges->len; i++)
		g_free(EDGE(graph, i));
	graph->nodes->len = graph->edges->len = 0;

	gtk_graph_update(graph);
}
Exemple #20
0
void bridgeR(Graph G, Edge e)
{
    link t;
    int v, w = e.w;
    pre[w] = time++;
    low[w] = pre[w];
    for (t = G->adj[w]; t != NULL; t = t->next)
        if (pre[v = t->v] == -1)
        {
            bridgeR(G, EDGE(w, v));
            if (low[w] > low[v])
                low[w] = low[v];
            if (low[v] == pre[v])
            {
                bcnt++;
                printf("edge %d - %d is a bridge \n", w, v);
            }
        }
        else if (v != e.v)
            if(low[w] > pre[v])
                low[w] = pre[v];
}
Exemple #21
0
Edge* EdgegetOUT(Graph G,int a,int *n){

    Edge *e;
    int i,j=0,cont=0;

    for(i=0;i<G->V;i++){
        if(G->adj[a][i]!=0)
        cont++;
    }

    *n=cont;
    e=malloc(cont*sizeof(Edge));

    for(i=0;i<G->V;i++){
        if(G->adj[a][i]!=0){
            e[j]=EDGE(a,i,G->adj[a][i]);
            j++;
        }
    }

    return e;

}
Exemple #22
0
void GRAPHdfs(Graph G)
{
    int v;
    time = 0;
    for (v=0; v < G->V; v++)
    {
      pre[v] = -1;
      post[v] = -1;
      st[v] =  -1;
    }
    for (v=0; v < G->V; v++)
      if (pre[v]== -1)
        dfsR(G, EDGE(v,v));

    printf("discovery/endprocessing time labels \n");
    for (v=0; v < G->V; v++)
        printf("vertex %d : %d/%d \n", v, pre[v], post[v]);

    printf("resulting DFS tree \n");
    for (v=0; v < G->V; v++)
        printf("parent of vertex %d is vertex  %d \n", v, st[v]);

}
Exemple #23
0
void expand() {
	RESET(7)
	NODE(7)
	ORFAIL

	RESET(8)
	EDTO(7, 8)
	ORBACK

	RESET(9)
	EDFR(7, 9)
	ORBACK

	RESET(10)
	EDGE(7, 10)
	ORBACK


}

void Modify() {
	CALL(inc)
	ORFAIL
	ALAP(prepare)
	ALAP(expand)
}

void GPMAIN() {
	CALL(init)
	ORFAIL
Exemple #24
0
edge rotate(edge e, int axis, float angle) {
    float A[4][4];
    generate_rotation_matrix(A, axis, angle);
    return EDGE(transform(e.first, A), transform(e.second, A));
}
Exemple #25
0
edge translate(edge e, float dx, float dy, float dz) {
    float A[4][4];
    generate_translation_matrix(A, dx, dy, dz);
    return EDGE(transform(e.first, A), transform(e.second, A));
}
Exemple #26
0
edge transform(edge e, float A[4][4]) {
    return EDGE(transform(e.first, A), transform(e.second, A));
}
Exemple #27
0
/* Main */
int main(int argc, char* argv[]) {
    int    nnF = 200000, nnV = 200000, nnT = 1100000;
    int     nF = 0,        nV = 0,        nT = 0;
    int    *face   = 0, *facematerial  = 0, *facedup = 0, *facematdup = 0;
    int    *tetra  = 0, *tetramaterial = 0;
    double *vertex = 0;
    int    i, nFdup, r, j, medge, msurf, m, k, p;
    int    nVVert,    nLine,  nSurface;
    int    *LineD,    *LineP;
    double *LineT;
    int    *SurfL,    *SurfI;
    double *SurfT;
    double *VVert;
    int *expCrv;
    int nE = 0, nnE = 100000, *edge, *edgematerial;

    int va, vb, vc, vd, ve, vf, vg, vh;
    int vc1a, vc1b, vc2a, vc2b, vc3a, vc3b;
    int arc1a, arc1b, arc2a, arc2b, arc3a, arc3b;
    int eab, ebc, ecd, eda, eef, efg, egh, ehe, eae, ebf, ecg, edh;

    int ntfix = 0,  nvfix = 0;

    int izero = 0;

    // allocate memory for mesh ctructures
    vertex        = (double*)malloc(sizeof(double) * 3 * nnV);
    face          = (int*)   malloc(sizeof(int)    * 3 * nnF);
    facedup       = (int*)   malloc(sizeof(int)    * 3 * nnF);
    facematerial  = (int*)   malloc(sizeof(int)        * nnF);
    facematdup    = (int*)   malloc(sizeof(int)        * nnF);
    tetra         = (int*)   malloc(sizeof(int)    * 4 * nnT);
    tetramaterial = (int*)   malloc(sizeof(int)        * nnT);
    edge          = (int*)   malloc(sizeof(int)    * 2 * nnE);
    edgematerial  = (int*)   malloc(sizeof(int)        * nnE);

    // allocate memory for boundary representation structure
    VVert = (double*)malloc(sizeof(double) * 3*100);
    nVVert = 0;
    LineD = (int*)   malloc(sizeof(int)    * 3*100);
    LineP = (int*)   malloc(sizeof(int)    * 2*2*100);
    LineT = (double*)malloc(sizeof(double) * 2*2*100);
    nLine = 0;
    SurfL = (int*)   malloc(sizeof(int)    * 5*100);
    SurfI = (int*)   malloc(sizeof(int)    * 2*2*100);
    SurfT = (double*)malloc(sizeof(double) * 4*100);
    nSurface = 0;

    expCrv = (int*)   malloc(sizeof(int)    * 100);
    memset(expCrv, 0, sizeof(int)    * 100);

    /***/
#define ADD_VERTEX(X, Y, Z)  (VVert[3*nVVert+0] = X,  VVert[3*nVVert+1] = Y,  VVert[3*nVVert+2] = Z,  ++nVVert)
#define EDGE(V1, V2, N, ...)  add_edge(LineD, LineP, LineT, &nLine, &medge, V1, V2, N, __VA_ARGS__)
#define SURF(P, C1, C2, D, U1, U2, V1, V2, N, ...) add_surf(SurfL, SurfT, SurfI, &nSurface, &msurf, P, C1, C2, D, U1, U2, V1, V2, N, __VA_ARGS__)
    /***/

    vc1a = ADD_VERTEX( R1, 0, 0);
    vc1b = ADD_VERTEX(-R1, 0, 0);
    vc2a = ADD_VERTEX( R2, 0, 0);
    vc2b = ADD_VERTEX(-R2, 0, 0);
    vc3a = ADD_VERTEX( R3, 0, 0);
    vc3b = ADD_VERTEX(-R3, 0, 0);
    va = ADD_VERTEX(-Db, -Db, 0);
    vb = ADD_VERTEX(-Db,  Db, 0);
    vc = ADD_VERTEX( Db,  Db, 0);
    vd = ADD_VERTEX( Db, -Db, 0);
    ve = ADD_VERTEX(-Db, -Db, -Db);
    vf = ADD_VERTEX(-Db,  Db, -Db);
    vg = ADD_VERTEX( Db,  Db, -Db);
    vh = ADD_VERTEX( Db, -Db, -Db);

    medge = 0;

    /* EDGE(v1, v2, nSurf,  [iSurf, iLine, t_0, t1,] ...); */

    arc1a = EDGE(vc1a, vc1b, 1, 1, 1, 0.0, M_PI);
    arc1b = EDGE(vc1b, vc1a, 1, 1, 1, M_PI, 2.0*M_PI);
    arc2a = EDGE(vc2a, vc2b, 1, 1, 2, M_PI, 0.0);
    arc2b = EDGE(vc2b, vc2a, 1, 1, 2, 2.0*M_PI, M_PI);
    arc3a = EDGE(vc3a, vc3b, 1, 1, 3, 0.0, M_PI);
    arc3b = EDGE(vc3b, vc3a, 1, 1, 3, M_PI, 2.0*M_PI);
    expCrv[arc1a-1] = 1,  expCrv[arc1b-1] = 1;
    expCrv[arc2a-1] = 1,  expCrv[arc2b-1] = 1;
    expCrv[arc3a-1] = 1,  expCrv[arc3b-1] = 1;
    
    eab = EDGE(va, vb, 1, 0, 0, 0.0, 0.0);
    ebc = EDGE(vb, vc, 1, 0, 0, 0.0, 0.0);
    ecd = EDGE(vc, vd, 1, 0, 0, 0.0, 0.0);
    eda = EDGE(vd, va, 1, 0, 0, 0.0, 0.0);

    eef = EDGE(ve, vf, 1, 0, 0, 0.0, 0.0);
    efg = EDGE(vf, vg, 1, 0, 0, 0.0, 0.0);
    egh = EDGE(vg, vh, 1, 0, 0, 0.0, 0.0);
    ehe = EDGE(vh, ve, 1, 0, 0, 0.0, 0.0);

    eae = EDGE(va, ve, 1, 0, 0, 0.0, 0.0);
    ebf = EDGE(vb, vf, 1, 0, 0, 0.0, 0.0);
    ecg = EDGE(vc, vg, 1, 0, 0, 0.0, 0.0);
    edh = EDGE(vd, vh, 1, 0, 0, 0.0, 0.0);

    msurf = 0;

    /* SURF(iSurf, color1, color2, direction, u0, u1, v0, v1, n,  [edge, edge_dir,] ...); */

    SURF(1, 2, 11, 0, -Db, Db, -Db, Db, 2, arc1a, 0, arc1b, 0);
    SURF(1, 1,  0, 0, -Db, Db, -Db, Db, 4, arc2a, 1, arc2b, 1, arc1a, 1, arc1b, 1);
    SURF(1, 2, 12, 0, -Db, Db, -Db, Db, 4, arc3a, 0, arc3b, 0, arc2a, 0, arc2b, 0);
    
    SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 6, arc3a, 1, arc3b, 1, eab, 1, ebc, 1, ecd, 1, eda, 1);
    SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, eef, 0, efg, 0, egh, 0, ehe, 0);
    SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, eab, 0, ebf, 0, eef, 1, eae, 1);
    SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, ebc, 0, ecg, 0, efg, 1, ebf, 1);
    SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, ecd, 0, edh, 0, egh, 1, ecg, 1);
    SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, eda, 0, eae, 0, ehe, 1, edh, 1);

    tria_dump_front = 0;
    tria_debug_front = 0;
    region_dump_face = 0;

    printf("\n * Generating surface mesh\n");
    i = ani3d_surface_edges_boundary_(&nVVert, VVert, &nLine, LineD, LineP, LineT, &nSurface, SurfL, SurfI, SurfT,
	    NULL, surface_param, line_param, NULL/*periodic*/, fsize,
	    expCrv,
	    &nV, vertex, &nF, face, facematerial, &nE, edge, edgematerial,
	    &nnV, &nnF, &nnE
	    );
    free(VVert), free(LineD), free(LineP), free(LineT), free(SurfL), free(SurfI), free(SurfT);


    printf("INFO: nV = %d, nE = %d, nF = %d, nT = %d\n", nV, nE, nF, nT);

    /* Generate skin mesh */
    printf("\n * Generating skin mesh\n");
    nFdup = 0;
    addlayer(electrodesize, &nV, vertex-3, nE, edge, edgematerial, &nF, face, facematerial, &nT, tetra, tetramaterial, &nFdup, facedup, facematdup, nnV, nnF, nnT);
    fix_vertices(&nV, vertex-3, nF, face, nT, tetra, nFdup, facedup, nE, edge);
    printf("INFO: nV = %d, nF = %d, nT = %d\n", nV, nF, nT);

    // It could be usefull to dump the triangulation of the surface in case we want to check
    // that boundary representation is correct and represents the desired region
    if (0) {
	write_mesh_gmv("surf.gmv", nV, vertex, nF, face, facematerial, nT, tetra, tetramaterial); // for GMV
	write_front   ("surf.smv", nV, vertex, nF, face, facematerial); // for smv
	//		return 0; // do not mesh the volume, just exit
	write_mesh_gmv("dups.gmv", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial); // for GMV
	write_front   ("dups.smv", nV, vertex, nFdup, facedup, facematdup); // for smv
    }
    // We will copy the front, so that it could be used in output in future.

    ntfix = nT;
    nvfix = nV;

    for (i=0; i<nF; i++) {
	facedup[3*nFdup+0] = face[3*i+0];
	facedup[3*nFdup+1] = face[3*i+1];
	facedup[3*nFdup+2] = face[3*i+2];
	facematdup[nFdup] = facematerial[i];
	nFdup++;
    }

    // Generate 3D mesh using our own size function fsize()
    printf("\n * Generating volume mesh\n");
    r = mesh_3d_aft_func_(&nV, vertex, &nF, face, facematerial, &nT, tetra, tetramaterial, &nnV, &nnF, &nnT, fsize);
    printf("\nINFO: nV = %d, nF = %d, nT = %d\n", nV, nF, nT);

    if (r) {
	write_mesh_gmv("fail.gmv", nV, vertex, nF, face, facematerial, nT, tetra, tetramaterial);
    } else {
	/* Check that 3D mesh corresponds with surface mesh */
	/*printf("Checking topology: "),  fflush(stdout);*/
	if (0 && check_mesh_topology_(&nV, vertex, &nFdup, facedup, &nT, tetra)) printf("FAILED!\n");
	else {
	    /*printf("ok.\n");*/

	    if (0) {
		write_mesh         ("bfix.out", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);
		write_mesh_gmv_qual("bfix.gmv", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);
	    }

	    for (i=0; i<nT; i++)  tetramaterial[i] = (tetramaterial[i]==1) ? 2 : tetramaterial[i];

	    keepskin(&nFdup, facedup, facematdup);

	    /* Improve mesh quality */
	    printf("\n * Smoothing volume mesh\n");
	    fixshape(&nV, vertex, &nT, tetra, tetramaterial, &nFdup, facedup, facematdup, 0, ntfix, nFdup, nnV, nnT, nnF);

	    keepskin(&nFdup, facedup, facematdup);

	    // Write output files
	    write_mesh_gmv_qual("mesh.gmv", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);
	    /*write_mesh         ("mesh.out", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);*/
	    saveMani(&nV, &nFdup, &nT,
		    vertex, facedup, tetra, facematdup, tetramaterial,
		    &izero, &izero, &izero, NULL, NULL, NULL,
		    &izero, NULL, NULL, "mesh.ani");
	}
    }

    free(vertex);
    free(face);
    free(facedup);
    free(facematerial);
    free(facematdup);
    free(tetra);
    free(tetramaterial);
    return 0;
}
Mesh * mesh_triangulate_polygon( const Polygon *poly )
{
    g_return_val_if_fail( poly != NULL, NULL );
    g_return_val_if_fail( poly->vertices != NULL, NULL );
    g_return_val_if_fail( g_list_length( poly->vertices ) >= 3, NULL );

    reflex_vertices = g_hash_table_new( NULL, NULL );
    convex_vertices = g_hash_table_new( NULL, NULL );
    ears = g_hash_table_new( NULL, NULL );

    /* create a new mesh */
    Mesh *mesh = mesh_new();
    /* add polygon's nodes and edges to the mesh */
    add_polygon_to_mesh( mesh, poly );

    /* take the first half-edge of the first edge as the starting half-edge */
    HalfEdge *he_start = &EDGE(mesh->edges->data)->he[0];
    HalfEdge *he_iter = he_start;
    /* iterate over half-edges lying on the inner side of the boundary */
    do
    {
        /* classify half-edge's origin according to its convexity */
        if ( halfedge_origin_is_convex( he_iter ) )
            g_hash_table_insert( convex_vertices, he_iter->origin, he_iter );
        else
            g_hash_table_insert( reflex_vertices, he_iter->origin, he_iter );

        he_iter = he_iter->next;
    }
    while ( he_iter != he_start );

    /* iterate over convex vertices */
    GHashTableIter convex_vert_iter;
    g_hash_table_iter_init( &convex_vert_iter, convex_vertices );
    gpointer key, value;
    while ( g_hash_table_iter_next( &convex_vert_iter, &key, &value ) )
    {
        HalfEdge *conv_he = HALFEDGE(value);
        /* check if the convex vertex is an ear */
        if ( halfedge_origin_is_ear( conv_he ) )
            g_hash_table_insert( ears, conv_he->origin, conv_he );
    }

    /* iterate over ears */
    GHashTableIter ears_iter;
    g_hash_table_iter_init( &ears_iter, ears );
    while ( g_hash_table_iter_next( &ears_iter, &key, &value) )
    {
        /* since we will cut it off, remove the ear from ears and convex vertex
         * hash table */
        g_hash_table_remove( ears, key );
        g_hash_table_remove( convex_vertices, key );

        HalfEdge *he2 = HALFEDGE(value);
        HalfEdge *he1 = he2->previous;
        Node *n1 = he1->origin;
        Node *n3 = he2->pair->origin;

        /* cut off the ear: */
        /* add an edge connecting the ear's neighbours */
        Edge *e = mesh_add_edge( mesh, n3, n1 );
        HalfEdge *he3 = &e->he[0];
        /* add ear's triangle to the mesh */
        mesh_add_element( mesh, he1, he2, he3 );

        he1 = &e->he[1];
        he2 = he1->next;

        gboolean was_reflex_1 = FALSE;
        gboolean was_reflex_became_convex_1 = FALSE;
        gboolean was_reflex_2 = FALSE;
        gboolean was_reflex_became_convex_2 = FALSE;

        /* update the status of the ear's neighbours */

        /* first, we need to update the reflex status of both neighbours, as
         * we need up-to-date info about reflex vertices in the "ear-ness" test */
        if ( g_hash_table_lookup( reflex_vertices, n1 ) )
        {
            was_reflex_1 = TRUE;
            /* reflex vertex can become convex */
            if ( halfedge_origin_is_convex( he1 ) )
            {
                was_reflex_became_convex_1 = TRUE;
                /* is now convex, remove from reflex vertices */
                g_hash_table_remove( reflex_vertices, n1 );
            }
        }

        if ( g_hash_table_lookup( reflex_vertices, n3 ) )
        {
            was_reflex_2 = TRUE;
            if ( halfedge_origin_is_convex( he2 ) )
            {
                was_reflex_became_convex_2 = TRUE;
                g_hash_table_remove( reflex_vertices, n3 );
            }
        }

        /* now we can proceed with the other tests */
        if ( was_reflex_1 )
        {
            if ( was_reflex_became_convex_1 )
            {
                /* add to convex vertices */
                g_hash_table_insert( convex_vertices, n1, he1 );
                /* if was reflex and became convex and even an ear, add it to
                 * ears */
                if ( halfedge_origin_is_ear( he1 ) )
                    g_hash_table_insert( ears, n1, he1 );
            }
            else
                /* if it stayed reflex, just update it with a new half-edge */
                g_hash_table_insert( reflex_vertices, n1, he1 );
        }
        else if ( g_hash_table_lookup( ears, n1 ) )
        {
            /* if it was an ear and now is not, remove it from ears (but it
             * stays convex) */
            if ( ! halfedge_origin_is_ear( he1 ) )
                g_hash_table_remove( ears, n1 );
            else
                /* if it stayed an ear, just update it with a new half-edge */
                g_hash_table_insert( ears, n1, he1 );
        }
        else if ( g_hash_table_lookup( convex_vertices, n1 ) )
        {
            /* if it was convex and now became an ear, insert it into ears */
            if ( halfedge_origin_is_ear( he1 ) )
                g_hash_table_insert( ears, n1, he1 );
            else
                /* otherwise just update it with a new half-edge */
                g_hash_table_insert( convex_vertices, n1, he1 );
        }

        /* the same process with the other neighbour */
        if ( was_reflex_2 )
        {
            if ( was_reflex_became_convex_2 )
            {
                g_hash_table_insert( convex_vertices, n3, he2 );
                if ( halfedge_origin_is_ear( he2 ) )
                    g_hash_table_insert( ears, n3, he2 );
            }
        }
        else if ( g_hash_table_lookup( ears, n3 ) )
        {
            if ( ! halfedge_origin_is_ear( he2 ) )
                g_hash_table_remove( ears, n3 );
        }
        else if ( g_hash_table_lookup( convex_vertices, n3 ) )
        {
            if ( halfedge_origin_is_ear( he2 ) )
                g_hash_table_insert( ears, n3, he2 );
        }
        
        /* we changed the ears, so update the iterator */
        g_hash_table_iter_init( &ears_iter, ears );

        he3 = he2->next;
        /* check if there are only three edges left */
        if ( he3->next == he1 )
        {
            /* if there are, so just add this last element and break out from
             * the loop */
            mesh_add_element( mesh, he1, he2, he3 );
            break;
        }
    }

    /* clean up */
    g_hash_table_destroy( reflex_vertices );
    g_hash_table_destroy( convex_vertices );
    g_hash_table_destroy( ears );

    /* return the resulting mesh */
    return mesh;
}
Exemple #29
0
edge dilate(edge e, float sx, float sy, float sz) {
    float A[4][4];
    generate_dilation_matrix(A, sx, sy, sz);
    return EDGE(transform(e.first, A), transform(e.second, A));
}
Exemple #30
0
X3D_BoundRegion* x3d_construct_boundregion_from_clip_data(X3D_ClipData* clip, uint16* edge_list, uint16 total_e, X3D_BoundRegion* region, _Bool clockwise) {
  X3D_BoundRegion* result_region = region;
  
  region->total_bl = 0;
  
  int16 reverse_edge_list[total_e];
  
  // If not clockwise, reverse the list of edges
  if(!clockwise) {
    uint16 i;
    
    for(i = 0; i < total_e; ++i) {
      reverse_edge_list[i] = edge_list[total_e - i - 1];
      
      SWAP(EDGE(i).v[0], EDGE(i).v[1]);
    }
    
    edge_list = reverse_edge_list;
    
  }
  
  uint16 edge_id = 0;
  
  // Skip over edges that are totally invisible
  while(edge_id < total_e && EDGE(edge_id).v[0].clip_status == CLIP_INVISIBLE) {
    ++edge_id;
  }
  
  uint16 first_visible_edge = 0xFFFF;
  
  if(edge_id < total_e) {
    
    while(edge_id != first_visible_edge) {
      // Alright, so we've encountered an edge that is at least partially visible
      X3D_ClippedEdge* edge = &EDGE(edge_id);
      
      // We're only interested in edges that are either totally visible, or begin in the
      // bounding region and exit
      if(edge->v[0].clip_status == CLIP_VISIBLE || edge->v[0].clip_status == CLIP_CLIPPED) {
        if(first_visible_edge == 0xFFFF) {
          first_visible_edge = edge_id;
          region->point_inside = edge->v[0].v;
        }
        
        if(edge->v[1].clip_status == CLIP_CLIPPED) {
          
          // Construct a bounding line for the edge
          x3d_construct_boundline(region->line + region->total_bl, &EDGE(edge_id).v[0].v, &EDGE(edge_id).v[1].v);
          
          if(region->total_bl == 0 || diff_boundline(region->line + region->total_bl, region->line + region->total_bl - 1))
            ++region->total_bl;
          
          
          uint16 start_edge = edge_id;
          
          // Walk along the old bounding region until we find an edge where we reenter it
          do {
            edge_id = x3d_single_wrap(edge_id + 1, total_e);
          } while(EDGE(edge_id).v[1].clip_status != CLIP_VISIBLE && EDGE(edge_id).v[1].clip_status != CLIP_CLIPPED);
          
          // Add the edges along the old bound region
          uint16 start = EDGE(start_edge).v[1].clip_line;
          uint16 end = EDGE(edge_id).v[0].clip_line;
          
          if(diff_boundline(clip->region->line + start, region->line + region->total_bl - 1))
            region->line[region->total_bl++] = clip->region->line[start];
          
          // Prevent special case of when it enters and exits on the same edge
          if(start != end) {
            uint16 e = start;
            
            do {
              e = x3d_single_wrap(e + 1, clip->region->total_bl);
              
              if(diff_boundline(clip->region->line + e, region->line + region->total_bl - 1))
                region->line[region->total_bl++] = clip->region->line[e];
            } while(e != end);
          }
          else {
            
          }
          
          continue;
          
        }
        
        
        x3d_construct_boundline(region->line + region->total_bl, &EDGE(edge_id).v[0].v, &EDGE(edge_id).v[1].v);
        
        if(region->total_bl == 0 || diff_boundline(region->line + region->total_bl, region->line + region->total_bl - 1))
          ++region->total_bl;
      }
      
      edge_id = x3d_single_wrap(edge_id + 1, total_e);
    }
    
    
  }
  else {
    uint16 i;
    uint32 edge_mask = (1L << clip->region->total_bl) - 1;// = clip->outside_mask[clip->edge->v[0]];
    
    printf("Begin: %ld\n", edge_mask);
    
    for(i = 0; i < total_e; ++i) {
      printf("Mask: %ld\n", clip->outside_mask[clip->edge[edge_list[i]].v[0]]);
      edge_mask &= clip->outside_mask[clip->edge[edge_list[i]].v[0]];
    }
    
    if(edge_mask != 0) {
      result_region = NULL;
      printf("EDGE FAIL\n");
    }
    else {
      for(i = 0; i < total_e; ++i) {
        if(x3d_is_clockwise_turn(&EDGE(i).v[0].v, &clip->region->point_inside, &EDGE(i).v[1].v)) {
          result_region = NULL;
          break;
        }
      }
      
      // If we got through testing all the edges, and the point is inside, the
      // old region must be inside the new region
      if(result_region != NULL) {
        result_region = clip->region;
        printf("ASSIGN OLD\n");
      }
    }
  }
  
  // Swap them back
  if(!clockwise) {
    uint16 i;
    
    for(i = 0; i < total_e; ++i) {
      SWAP(EDGE(i).v[0], EDGE(i).v[1]);
    }
  }
  
  return result_region;
}