Ignore:
Timestamp:
02/19/07 09:16:59 (17 years ago)
Author:
gumbau
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/change.cpp

    r2090 r2127  
    157157  if (c->numMod > 0) { 
    158158      mesh->vertices[c->v].triangles =  
    159           (GLuint *)realloc(mesh->vertices[c->v].triangles,  
    160           (mesh->vertices[c->v].numTriangles + mesh->vertices[c->u].numTriangles) * sizeof(GLuint)); 
     159          (int *)realloc(mesh->vertices[c->v].triangles,  
     160          (mesh->vertices[c->v].numTriangles + mesh->vertices[c->u].numTriangles) * sizeof(int)); 
    161161  } 
    162162 
    … …  
    193193} 
    194194 
    195 int VMI::hasEdge(Triangle *t, int e) { 
    196     int e0 = t->edges[0], 
    197         e1 = t->edges[1], 
    198         e2 = t->edges[2]; 
    199      
    200     if ((e == e0) || (e == e1) || (e == e2)) return TRUE; 
    201  
    202     return FALSE; 
    203 } 
    204  
    205 void VMI::getEdges(Triangle *t, Change *c, int *l, int *r) { 
    206  
    207     // Default edges 
    208     *l = -1; 
    209     *r = -1; 
    210  
    211     // Set edge l and r 
    212     if ((int)t->edges[0] == c->e) { 
    213         *l = t->edges[1]; 
    214         *r = t->edges[2]; 
    215         if ((int)mesh->edges[*l].u == c->v || (int)mesh->edges[*l].v == c->v) 
    216             swap(l, r); 
    217     } else if ((int)t->edges[1] == c->e) { 
    218         *l = t->edges[0]; 
    219         *r = t->edges[2]; 
    220         if ((int)mesh->edges[*l].u == c->v || (int)mesh->edges[*l].v == c->v) 
    221             swap(l, r); 
    222     } else if ((int)t->edges[2] == c->e) { 
    223         *l = t->edges[0]; 
    224         *r = t->edges[1]; 
    225         if ((int)mesh->edges[*l].u == c->v || (int)mesh->edges[*l].v == c->v) 
    226             swap(l, r); 
    227     } 
    228 } 
    229  
    230195void VMI::swap(int *i, int *j) { 
    231196    int t; 
    … …  
    238203void VMI::deleteTriangles(Mesh *mesh, Change *c) 
    239204{ 
    240             int i, j, t, v; 
    241 #ifdef USE_EDGE_ADJACENCY 
    242     int t1, l, r; 
    243 #endif 
     205          int i, j, t, v; 
    244206     
    245207    for (i=0; i<c->numDel; i++) { 
    … …  
    255217        } 
    256218 
    257 #ifdef USE_EDGE_ADJACENCY 
    258         // Update triangle edge adjancency 
    259         // The modified triangles have to be calculated before 
    260         // Set edge l and r 
    261         getEdges(&c->deleted[i], c, &l, &r); 
    262         //printf("e%d(%d,%d): l:%d r:%d\n", c->e, c->u, c->v, l, r); 
    263         // Find triangle that contains edge l 
    264         for (j=0; j<c->numMod; j++) 
    265             if (hasEdge(&c->modified[j], l)) { 
    266                 // Change edge l by r in the Mesh 
    267                 t1 = c->modified[j].id; 
    268                 //printf("t:%d %d %d %d\n", t1, mesh->triangles[t1].edges[0], mesh->triangles[t1].edges[1] ,mesh->triangles[t1].edges[2]); 
    269                 if (mesh->triangles[t1].edges[0] == (GLuint)l) mesh->triangles[t1].edges[0] = r; 
    270                 if (mesh->triangles[t1].edges[1] == (GLuint)l) mesh->triangles[t1].edges[1] = r; 
    271                 if (mesh->triangles[t1].edges[2] == (GLuint)l) mesh->triangles[t1].edges[2] = r; 
    272                 //printf("t:%d %d %d %d\n", t1, mesh->triangles[t1].edges[0], mesh->triangles[t1].edges[1] ,mesh->triangles[t1].edges[2]); 
    273                 break; 
    274             } 
    275  
    276         // Delete edge l 
    277         if (l != -1) mesh->edges[l].enable = FALSE; 
    278 #endif 
    279219        mesh->triangles[t].enable = FALSE; 
    280220        mesh->currentNumTriangles--; 
    … …  
    301241            addItem((int *)mesh->vertices[v].triangles,(int *)&mesh->vertices[v].numTriangles,t); 
    302242        } 
    303 #ifdef USE_EDGE_ADJACENCY 
    304         // Enable adjacent edges 
    305         for (j=0; j<3; j++) { 
    306             mesh->edges[mesh->triangles[t].edges[j]].enable = TRUE; 
    307         } 
    308 #endif 
     243 
    309244        mesh->triangles[t].enable = TRUE; 
    310245        mesh->currentNumTriangles++; 
    … …  
    312247} 
    313248 
    314 Triangle *VMI::getTrianglesToModify(Mesh *mesh, Change *c, GLuint *numMod) { 
     249Triangle *VMI::getTrianglesToModify(Mesh *mesh, Change *c, int *numMod) { 
    315250  int i, t; 
    316251  Triangle *modified = NULL; 
    … …  
    336271} 
    337272 
    338 Triangle *VMI::getTrianglesToDelete(Mesh *mesh, Change *c, GLuint *numDel) { 
     273Triangle *VMI::getTrianglesToDelete(Mesh *mesh, Change *c, int *numDel) { 
    339274  int i, t; 
    340275  Triangle *deleted = NULL; 
    … …  
    359294} 
    360295 
    361 void VMI::deleteEdges(Mesh *mesh, Change *c) { 
     296void VMI::modifyEdges(Mesh *mesh, Change *c) { 
    362297    int i, e; 
    363 #ifndef USE_EDGE_ADJACENCY 
    364     int n0, n1, n2; 
    365 #else 
    366     int j, u, v; 
    367 #endif 
    368  
    369 #ifdef USE_EDGE_ADJACENCY 
    370     for (i=0; i<c->numDel; i++) { 
     298 
     299        for(i = 0; i < mesh->vertices[c->v].numEdges; i++) { 
    371300         
    372         for (j=0; j<3; j++) { 
    373             e = c->deleted[i].edges[j]; 
    374             if (e != c->e) { 
    375                 u = mesh->edges[e].u; 
    376                 v = mesh->edges[e].v; 
    377                 if (u == c->u || v == c->u) { 
    378                     //printf("%d\n",j); 
    379                     mesh->edges[e].enable = FALSE; 
    380                 } 
    381             } 
    382         } 
    383         //getchar(); 
    384     } 
    385 #else 
    386     for (i=0; i<c->numDel; i++) { 
    387  
    388         n0 = c->deleted[i].indices[0]; 
    389         n1 = c->deleted[i].indices[1]; 
    390         n2 = c->deleted[i].indices[2]; 
    391  
    392         if ((n0 == c->u && n1 != c->v) || (n1 == c->u && n0 != c->v)) { 
    393             e = findEdge(mesh->edges, mesh->numEdges, n0, n1); 
    394  
    395             //printf("a\n"); 
    396             if (e != -1) 
    397                 mesh->edges[e].enable = FALSE; 
    398         } 
    399  
    400         if ((n1 == c->u && n2 != c->v) || (n2 == c->u && n1 != c->v)) { 
    401             e = findEdge(mesh->edges, mesh->numEdges, n1, n2); 
    402              
    403             //printf("b\n"); 
    404             if (e != -1) 
    405                 mesh->edges[e].enable = FALSE; 
    406         } 
    407  
    408         if ((n0 == c->u && n2 != c->v) || (n2 == c->u && n0 != c->v)) { 
    409             e = findEdge(mesh->edges, mesh->numEdges, n0, n2); 
    410              
    411             //printf("c\n"); 
    412             if (e != -1) 
    413                 mesh->edges[e].enable = FALSE; 
    414         } 
    415         //getchar(); 
    416     } 
    417 #endif 
    418 } 
    419  
    420 void VMI::modifyEdges(Mesh *mesh, Change *c) { 
    421     int e, u, v; 
    422      
    423     // Update mesh and heap 
    424     for(e = 0; e < (int)mesh->numEdges; e++) { 
    425          
     301                e = mesh->vertices[c->v].edges[i]; 
     302 
    426303        if (mesh->edges[e].enable == TRUE) { 
    427304             
    428305            // Modify edge 
    429             if ((int)mesh->edges[e].u == c->u) 
     306            if (mesh->edges[e].u == c->u) 
    430307                mesh->edges[e].u = c->v; 
    431308             
    432             if ((int)mesh->edges[e].v == c->u) 
     309            if (mesh->edges[e].v == c->u) 
    433310                mesh->edges[e].v = c->v; 
    434              
    435             // Check edge 
    436             u = mesh->edges[e].u; 
    437             v = mesh->edges[e].v; 
    438              
    439             // if the edge is not valid, we simply delete it 
    440             if ((u == v) ||  
    441                 (u == c->u) || (v == c->u))  
    442                  
    443                 mesh->edges[e].enable = FALSE; 
    444311        } 
    445312    } 
    446313} 
    447314 
     315int VMI::find(int *edges, int num, int v_) { 
     316        int i; 
     317 
     318        int u, v; 
     319 
     320 
     321        for(i=0; i<num; i++) { 
     322 
     323                u = mesh->edges[edges[i]].u; 
     324 
     325                v = mesh->edges[edges[i]].v; 
     326 
     327                if (u == v_ || v == v_) return TRUE; 
     328 
     329        } 
     330 
     331        return FALSE; 
     332} 
     333void VMI::updateEdgeAdj(Mesh *mesh, Change *c) { 
     334        int i; 
     335 
     336        int v, e; 
     337 
     338        mesh->vertices[c->v].edges =  
     339            (int *)realloc(mesh->vertices[c->v].edges,  
     340            (mesh->vertices[c->v].numEdges + mesh->vertices[c->u].numEdges) * sizeof(int)); 
     341 
     342        for (i=0; i<mesh->vertices[c->u].numEdges; i++) { 
     343         
     344                e = mesh->vertices[c->u].edges[i]; 
     345                if (mesh->edges[e].u == c->u) v =mesh->edges[e].v; 
     346                else v = mesh->edges[e].u; 
     347                 
     348                if (!find(mesh->vertices[c->v].edges, mesh->vertices[c->v].numEdges, v)) 
     349                        addItem(mesh->vertices[c->v].edges, &mesh->vertices[c->v].numEdges, e); 
     350                else mesh->edges[e].enable = FALSE; 
     351        } 
     352 
     353        delItem(mesh->vertices[c->v].edges, &mesh->vertices[c->v].numEdges, c->e); 
     354} 
     355 
    448356/////////////////////////////////////////////////////////////////////////////// 
    449357 
    450358// Compute the triangle mesh changes due to a heap node simplification 
    451359void VMI::computeChange(Mesh *mesh, Change *c) { 
    452   GLuint numMod, numDel; 
     360  int numMod, numDel; 
    453361  Triangle *m = getTrianglesToModify(mesh, c, &numMod), 
    454362            *d = getTrianglesToDelete(mesh, c, &numDel); 
Note: See TracChangeset for help on using the changeset viewer.