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/mesh.cpp

    r2090 r2127  
    5353/////////////////////////////////////////////////////////////////////////////// 
    5454 
    55 int VMI::findEdge(Edge *e, GLuint num, GLuint _u, GLuint _v) { 
    56     GLuint i, u, v; 
     55int VMI::findEdge(Edge *e, int num, int _u, int _v) { 
     56    int i, u, v; 
    5757    int found = -1;  
    5858 
    … …  
    8585                newList[*n].u = u; 
    8686    newList[*n].v = v; 
    87  
    88                 // This edge has no triangle adjancency 
    89                 newList[*n].numTriangles = 0; 
    90                 newList[*n].triangles = NULL; 
    9187                 
    9288                // Enable the new edge 
    … …  
    10298} 
    10399 
     100double VMI::computeEdgeLength(Vertex *vertices, int u, int v) { 
     101    float ux, uy, uz, vx, vy ,vz, rx, ry, rz; 
     102     
     103    ux = vertices[u].x; 
     104    uy = vertices[u].y; 
     105    uz = vertices[u].z; 
     106 
     107    vx = vertices[v].x; 
     108    vy = vertices[v].y; 
     109    vz = vertices[v].z; 
     110 
     111    rx = ux - vx; 
     112    ry = uy - vy; 
     113    rz = uz - vz; 
     114 
     115    return sqrt((rx * rx) + (ry * ry) + (rz * rz)); 
     116} 
     117 
     118double VMI::computeTriangleVolume(Vertex *vertices, Triangle *t) { 
     119    int i; 
     120    double m[3][3], vol; 
     121     
     122    // Compute triangle Volume 
     123    i = t->indices[0]; 
     124    m[0][0] = mesh->vertices[i].x; 
     125    m[0][1] = mesh->vertices[i].y; 
     126    m[0][2] = mesh->vertices[i].z; 
     127     
     128    i = t->indices[1]; 
     129    m[1][0] = mesh->vertices[i].x; 
     130    m[1][1] = mesh->vertices[i].y; 
     131    m[1][2] = mesh->vertices[i].z; 
     132 
     133    i = t->indices[2]; 
     134    m[2][0] = mesh->vertices[i].x; 
     135    m[2][1] = mesh->vertices[i].y; 
     136    m[2][2] = mesh->vertices[i].z; 
     137     
     138    vol = computeMatDet(m); 
     139     
     140    //printf("Triangle Volume: %f\n", vol) 
     141    return vol;   
     142} 
     143 
    104144GLdouble VMI::computeTriangleArea(Vertex *vertices, Triangle *t) { 
    105     GLuint i; 
     145    int i; 
    106146    GLdouble v0[3], v1[3], v2[3], a; 
    107147     
    … …  
    129169 
    130170void VMI::computeTriangleNormal(Vertex *vertices, Triangle *t) { 
    131     GLuint i; 
     171    int i; 
    132172    GLfloat x0, y0, z0, 
    133173            x1, y1, z1, 
    … …  
    175215Mesh *VMI::initMesh(GLMmodel* pmodel) { 
    176216 
    177     GLuint i, j, curGroup, v1, v2, v3, n, m, t; 
     217    int i, j, curGroup, v1, v2, v3, n, m, t; 
    178218    int e; 
    179219    Mesh *mesh; 
    … …  
    202242     
    203243    printf("Adding vertices..."); 
    204     for (i=1; i<=pmodel->numvertices; i++) { // Vertices start at 1 
     244    for (i=1; i<=(int)pmodel->numvertices; i++) { // Vertices start at 1 
    205245        mesh->vertices[i - 1].x = pmodel->vertices[3 * i + 0]; 
    206246        mesh->vertices[i - 1].y = pmodel->vertices[3 * i + 1]; 
    … …  
    208248        mesh->vertices[i - 1].numTriangles = 0; 
    209249        mesh->vertices[i - 1].triangles = NULL; 
     250                                mesh->vertices[i - 1].numEdges = 0; 
     251        mesh->vertices[i - 1].edges = NULL; 
    210252        mesh->vertices[i - 1].enable = GL_TRUE; 
    211253    } 
    … …  
    221263    while(group) { 
    222264         
    223         for (i=0; i<group->numtriangles; i++) { 
     265        for (i=0; i<(int)group->numtriangles; i++) { 
    224266             
    225267            t = group->triangles[i]; 
    … …  
    244286                // Reallocate memory for the new adjacent triangle 
    245287                mesh->vertices[v1].triangles =  
    246                                         (GLuint *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(GLuint)); 
     288                                        (int *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(int)); 
    247289                addItem((int *)mesh->vertices[v1].triangles, (int *)&mesh->vertices[v1].numTriangles, t); 
    248290            } 
    … …  
    254296    for (i=0; i<pmodel->numtriangles; i++) { 
    255297        mesh->triangles[i].id = i; 
    256         mesh->triangles[i].indices[0] = pmodel->triangles[i].vindices[0] - 1; 
    257         mesh->triangles[i].indices[1] = pmodel->triangles[i].vindices[1] - 1; 
    258         mesh->triangles[i].indices[2] = pmodel->triangles[i].vindices[2] - 1; 
     298        mesh->triangles[i].indices[0] = (int)pmodel->triangles[i].vindices[0] - 1; 
     299        mesh->triangles[i].indices[1] = (int)pmodel->triangles[i].vindices[1] - 1; 
     300        mesh->triangles[i].indices[2] = (int)pmodel->triangles[i].vindices[2] - 1; 
    259301        mesh->triangles[i].area = computeTriangleArea(mesh->vertices, &mesh->triangles[i]); 
    260302        //printf("\n%d a: %f",i , mesh->triangles[i].area); 
    … …  
    271313            // Reallocate memory for the new adjacent triangle 
    272314            mesh->vertices[v1].triangles =  
    273                             (GLuint *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(GLuint)); 
     315                            (int *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(int)); 
    274316            addItem((int *)mesh->vertices[v1].triangles, (int *)&mesh->vertices[v1].numTriangles, i); 
    275317        } 
    … …  
    304346            mesh->edges[n].u = v1; 
    305347            mesh->edges[n].v = v2; 
    306                                                 mesh->edges[n].triangles    = NULL; 
    307                         mesh->edges[n].numTriangles = 0; 
    308348            mesh->edges[n].enable = GL_TRUE; 
    309349            m = n; 
    310350            n++; 
    311351        } else m = e; 
    312                 // Reallocate memory for the new adjacent triangle 
    313         mesh->edges[m].triangles =  
    314                         (GLuint *)realloc(mesh->edges[m].triangles, (mesh->edges[m].numTriangles + 1) * sizeof(GLuint)); 
    315         // Adding triangle i adjacent to edge m 
    316         addItem((int *)mesh->edges[m].triangles, (int *)&mesh->edges[m].numTriangles, i); 
    317         //printf("n:%d i:%d\n", m, i); 
    318          
    319         // Adding edge m adjacent to triangle i 
    320         addItem((int *)mesh->triangles[i].edges, (int *)&t, m); 
    321352 
    322353        ///////////////////////////////////////////////////////////////////////////////// 
    … …  
    325356            mesh->edges[n].u = v2; 
    326357            mesh->edges[n].v = v3; 
    327                                                 mesh->edges[n].triangles    = NULL; 
    328                         mesh->edges[n].numTriangles = 0; 
    329358            mesh->edges[n].enable = GL_TRUE; 
    330359            m = n; 
    331360            n++; 
    332361        } else m = e; 
    333                 // Reallocate memory for the new adjacent triangle 
    334         mesh->edges[m].triangles =  
    335                         (GLuint *)realloc(mesh->edges[m].triangles, (mesh->edges[m].numTriangles + 1) * sizeof(GLuint)); 
    336         // Adding triangle i adjacent to edge m 
    337         addItem((int *)mesh->edges[m].triangles, (int *)&mesh->edges[m].numTriangles, i); 
    338         //printf("n:%d i:%d\n", m, i); 
    339          
    340         // Adding edge m adjacent to triangle i 
    341         addItem((int *)mesh->triangles[i].edges, (int *)&t, m); 
    342362 
    343363        ///////////////////////////////////////////////////////////////////////////////// 
    … …  
    346366            mesh->edges[n].u = v3; 
    347367            mesh->edges[n].v = v1; 
    348                                                 mesh->edges[n].triangles    = NULL; 
    349                         mesh->edges[n].numTriangles = 0; 
    350368            mesh->edges[n].enable = GL_TRUE; 
    351369            m = n; 
    352370            n++; 
    353371        } else m = e; 
    354                 // Reallocate memory for the new adjacent triangle 
    355         mesh->edges[m].triangles =  
    356                         (GLuint *)realloc(mesh->edges[m].triangles, (mesh->edges[m].numTriangles + 1) * sizeof(GLuint)); 
    357         // Adding triangle i adjacent to edge m 
    358         addItem((int *)mesh->edges[m].triangles, (int *)&mesh->edges[m].numTriangles, i); 
    359         //printf("n:%d i:%d\n", m, i); 
    360          
    361         // Adding edge m adjacent to triangle i 
    362         addItem((int *)mesh->triangles[i].edges, (int *)&t, m); 
    363372    } 
    364373    printf("Ok\n"); 
    365374    mesh->numEdges = n; 
    366375 
     376                for (i=0; i<mesh->numEdges; i++) { 
     377                        v1 = mesh->edges[i].u; 
     378                        v2 = mesh->edges[i].v; 
     379 
     380                        mesh->vertices[v1].edges =  
     381                                (int *)realloc(mesh->vertices[v1].edges, (mesh->vertices[v1].numEdges + 1) * sizeof(int)); 
     382                        // Adding edge i adjacent to vertex v1 
     383                        addItem(mesh->vertices[v1].edges, &mesh->vertices[v1].numEdges, i); 
     384 
     385                        mesh->vertices[v2].edges =  
     386                                (int *)realloc(mesh->vertices[v2].edges, (mesh->vertices[v2].numEdges + 1) * sizeof(int)); 
     387                        // Adding edge i adjacent to vertex v2 
     388                        addItem(mesh->vertices[v2].edges, &mesh->vertices[v2].numEdges, i); 
     389                } 
     390 
    367391    return mesh; 
    368392} 
    369393 
    370394void VMI::printMesh(Mesh *mesh) { 
    371     GLuint i, j; 
     395    int i, j; 
    372396 
    373397    printf("Vertices (%d)\n", mesh->numVertices); 
    … …  
    385409        } 
    386410        printf("]\n"); 
     411 
     412                                        printf("  e(%d)[", mesh->vertices[i].numEdges); 
     413        if (mesh->vertices[i].edges != NULL) { 
     414            printf("%d", mesh->vertices[i].edges[0]); 
     415            for (j=1; j<mesh->vertices[i].numEdges; j++) { 
     416                printf(",%d", mesh->vertices[i].edges[j]); 
     417            } 
     418        } 
     419        printf("]\n"); 
    387420    } 
    388421 
    … …  
    391424    for (i=0; i<mesh->numEdges; i++) { 
    392425        printf("e%d (%d,%d) %d\n", i, mesh->edges[i].u, mesh->edges[i].v, mesh->edges[i].enable); 
    393         printf("  t(%d)[", mesh->edges[i].numTriangles); 
    394         if (mesh->edges[i].triangles != NULL) { 
    395             printf("%d", mesh->edges[i].triangles[0]); 
    396             for (j=1; j<mesh->edges[i].numTriangles; j++) { 
    397                 printf(",%d", mesh->edges[i].triangles[j]); 
    398             } 
    399                                 } 
    400         printf("]\n"); 
    401426    } 
    402427 
    … …  
    406431        printf("t%d (%d,%d,%d) %d\n", i, mesh->triangles[i].indices[0], mesh->triangles[i].indices[1], 
    407432                                     mesh->triangles[i].indices[2],  mesh->triangles[i].enable); 
    408         printf("  e(3)["); 
    409         printf("%d", mesh->triangles[i].edges[0]); 
    410         for (j=1; j<3; j++) { 
    411             printf(",%d", mesh->triangles[i].edges[j]); 
    412         } 
    413         printf("]\n"); 
    414433 
    415434        printf("  n(3)["); 
    … …  
    425444 
    426445void VMI::deleteMesh(Mesh *mesh) { 
    427         GLuint i; 
     446        int i; 
    428447 
    429448        if (NULL != mesh) { 
    … …  
    432451                                free(mesh->vertices[i].triangles); 
    433452 
     453                        if (mesh->vertices[i].edges != NULL) 
     454                                free(mesh->vertices[i].edges); 
     455 
    434456                } 
    435457                if (mesh->vertices != NULL) free(mesh->vertices); 
    436458                mesh->numVertices = 0; 
    437459 
    438                 for (i=0; i<mesh->numEdges; i++) { 
    439                         if (mesh->edges[i].triangles != NULL) 
    440                                 free(mesh->edges[i].triangles); 
    441                 } 
    442460                if (mesh->edges != NULL) free(mesh->edges); 
    443461                mesh->numEdges = 0; 
    … …  
    525543} 
    526544 
    527 int *VMI::edgesAdjToVertex(Mesh *mesh, int v, int *n) { 
    528     int *edges = NULL; 
    529     int i, t, e; 
    530 #ifndef USE_EDGE_ADJACENCY 
    531     int n0, n1, n2; 
    532 #else 
    533     int j; 
    534 #endif 
    535     int num = 0; 
    536  
    537         if (mesh->vertices[v].numTriangles > 0)  
    538                 edges = (int*)malloc(sizeof(int) * mesh->vertices[v].numTriangles * 2); 
    539  
    540     for (i=0; i<(int)mesh->vertices[v].numTriangles; i++) { 
    541  
    542         t = mesh->vertices[v].triangles[i]; 
    543  
    544 #ifdef USE_EDGE_ADJACENCY 
    545         for (j=0; j<3; j++) { 
    546             e = mesh->triangles[t].edges[j]; 
    547              
    548             if ((int)mesh->edges[e].u == v || (int)mesh->edges[e].v == v) 
    549                  
    550                 addItem(edges, &num, e); 
    551         } 
    552 #else 
    553         n0 = mesh->triangles[t].indices[0]; 
    554         n1 = mesh->triangles[t].indices[1]; 
    555         n2 = mesh->triangles[t].indices[2]; 
    556          
    557         if (((n0 == v) || (n1 == v)) && 
    558             ((e = findEdge(mesh->edges, mesh->numEdges, n0, n1)) != -1)) addItem(edges, &num, e); 
    559   
    560         if (((n1 == v) || (n2 == v)) && 
    561             ((e = findEdge(mesh->edges, mesh->numEdges, n1, n2)) != -1)) addItem(edges, &num, e); 
    562          
    563         if (((n0 == v) || (n2 == v)) && 
    564             ((e = findEdge(mesh->edges, mesh->numEdges, n0, n2)) != -1)) addItem(edges, &num, e); 
    565  
    566 #endif 
    567     } 
    568     *n = num; 
    569  
    570     return edges; 
    571 } 
    572  
    573545int *VMI::edgesAdjToVertices(Mesh *mesh, int *vertices, int numVertices, int *n) { 
    574546    int *edges = NULL; 
    … …  
    578550    if (numVertices > 0) { 
    579551        // Add the first 
    580         list = edgesAdjToVertex(mesh, vertices[0], &numEdges); 
     552                list = mesh->vertices[vertices[0]].edges; 
     553                numEdges = mesh->vertices[vertices[0]].numEdges; 
    581554 
    582555        // Allocate memory 
    … …  
    585558        memcpy(edges, list, sizeof(int) * numEdges); 
    586559 
    587         free(list); 
    588  
    589560        num = numEdges; 
    590561 
    … …  
    592563        for (i=1; i<numVertices; i++) { 
    593564 
    594             list = edgesAdjToVertex(mesh, vertices[i], &numEdges); 
     565                        list = mesh->vertices[vertices[i]].edges; 
     566                    numEdges = mesh->vertices[vertices[i]].numEdges; 
    595567 
    596568            // Reallocate memory 
    597                         if (numEdges > 0) { 
     569            if (numEdges > 0) { 
    598570 
    599571                edges = (int *)realloc(edges, (num + numEdges + 1) * sizeof(int)); 
    … …  
    601573                for (j=0; j<numEdges; j++) 
    602574                    addItem(edges, &num, list[j]); 
    603                         } 
    604             free(list); 
     575            } 
    605576        } 
    606577    } 
    … …  
    610581} 
    611582 
    612 GLboolean VMI::findVertex(GLfloat *vertices, GLuint num, GLfloat x, GLfloat y, GLfloat z, int *pos) { 
    613     GLuint i; 
    614     GLfloat _x, _y, _z; 
     583GLboolean VMI::findVertex(float *vertices, int num, float x, float y, float z, int *pos) { 
     584    int i; 
     585    float _x, _y, _z; 
    615586    GLboolean found = GL_FALSE;  
    616587     
    … …  
    648619                newList[*n].numTriangles = 0; 
    649620                newList[*n].triangles = NULL; 
     621 
     622                newList[*n].numEdges= 0; 
     623                newList[*n].edges = NULL; 
    650624         
    651625    // Enable the new vertex 
    … …  
    663637 
    664638 
    665 void VMI::updateModel(GLMmodel* pmodel, Mesh *mesh, GLuint numVertices, GLuint numTriangles) { 
    666     GLuint i , v1, v2 ,v3, numV = 1, numT = 0; 
     639void VMI::updateModel(GLMmodel* pmodel, Mesh *mesh, int numVertices, int numTriangles) { 
     640    int i , v1, v2 ,v3, numV = 1, numT = 0; 
    667641    int pos; 
    668     GLfloat x, y, z; 
     642    float x, y, z; 
    669643     
    670644    if (pmodel->vertices != NULL) free(pmodel->vertices); 
    … …  
    726700 
    727701void VMI::saveModel(char *filename, GLMmodel* pmodel, Mesh *mesh) { 
    728     GLuint i, j, g, numT = 0; 
     702    int i, j, g, numT = 0; 
    729703    GLMgroup *group; 
    730704 
Note: See TracChangeset for help on using the changeset viewer.