Changeset 2323 for GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs

Timestamp:

04/12/07 09:25:16 (18 years ago)

Author:

gumbau

Message:

 

Location:

GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi

Files:

• include/mesh.h (modified) (1 diff)
• src/mesh.cpp (modified) (1 diff)
• src/saliency.cpp (modified) (1 diff)

GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/include/mesh.h

@@ -47 +47 @@
 extern double computeTriangleVolume(Vertex *vertices, Triangle *t);
 
+extern int addEdge(Mesh *mesh, int u, int v);
+extern int addTriangle(Mesh *mesh, int curGroup, int v1, int v2, int v3);
+extern int addVertex(Mesh *mesh, float x, float y, float z);
+
 extern Vertex *addVertex(Vertex *list, int *n, float x, float y, float z, int *pos);
 extern int findEdge(Edge *e, int num, int _u, int _v);

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

@@ -212 +212 @@
     t->normal[2] = cpz / r;
 }
+int VMI::addEdge(Mesh *mesh, int u, int v) {
+        int n = mesh->numEdges;
+        
+        mesh->edges[n].u = u;
+        mesh->edges[n].v = v;
+        mesh->edges[n].enable = TRUE;
+        
+        mesh->vertices[u].edges = 
+                (int *)realloc(mesh->vertices[u].edges, (mesh->vertices[u].numEdges + 1) * sizeof(int));
+        // Adding edge n adjacent to vertex u
+        addItem(mesh->vertices[u].edges, &mesh->vertices[u].numEdges, n);
+        
+        mesh->vertices[v].edges = 
+                (int *)realloc(mesh->vertices[v].edges, (mesh->vertices[v].numEdges + 1) * sizeof(int));
+        // Adding edge n adjacent to vertex v
+        addItem(mesh->vertices[v].edges, &mesh->vertices[v].numEdges, n);
+        
+        mesh->numEdges++;
+        
+        return n;
+}
+
+int VMI::addVertex(Mesh *mesh, float x, float y, float z) {
+        int n = mesh->numVertices;
+
+        mesh->vertices[n].x = x;
+        mesh->vertices[n].y = y;
+        mesh->vertices[n].z = z;
+        mesh->vertices[n].numTriangles = 0;
+        mesh->vertices[n].triangles = NULL;
+        mesh->vertices[n].numEdges = 0;
+        mesh->vertices[n].edges = NULL;
+        mesh->vertices[n].enable = TRUE;
+
+        mesh->numVertices++;
+
+        return n;
+}
+
+int VMI::addTriangle(Mesh *mesh, int curGroup, int v1, int v2, int v3) {
+        int j, n = mesh->numTriangles;
+
+        mesh->triangles[n].id = n;
+        mesh->triangles[n].group = curGroup; // set group
+        mesh->triangles[n].submesh = curGroup; // set group
+        mesh->triangles[n].indices[0] = v1;
+        mesh->triangles[n].indices[1] = v2;
+        mesh->triangles[n].indices[2] = v3;
+        mesh->triangles[n].area = computeTriangleArea(mesh->vertices, &mesh->triangles[n]);
+        //printf("\n%d a: %f",i , mesh->triangles[i].area);
+        computeTriangleNormal(mesh->vertices, &mesh->triangles[n]);
+        mesh->triangles[n].saliency = 0.0;
+        mesh->triangles[n].enable = TRUE;
+
+        for (j=0; j<3; j++) {
+                // Adding triangle n adjacent to 3 vertices
+                v1 = mesh->triangles[n].indices[j];
+
+                // Reallocate memory for the new adjacent triangle
+                mesh->vertices[v1].triangles = 
+                        (int *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(int));
+                addItem(mesh->vertices[v1].triangles, &mesh->vertices[v1].numTriangles, n);
+        }
+
+        mesh->numTriangles++;
+
+        return n;
+}
 
 Mesh *VMI::initMesh(GLMmodel* pmodel) {
-
-    int i, j, curGroup, v1, v2, v3, n, m, t;
-    int e;
-    Mesh *mesh;
-    GLMgroup *group;
-
-    mesh = (Mesh *)malloc (sizeof(Mesh));
-    
-    if (mesh == NULL) {
-        fprintf(stderr, "Error allocating memory\n");
-        exit(1);
-    }
-
-    mesh->vertices = (Vertex *)malloc (sizeof(Vertex) * pmodel->numvertices);
-    
-    if (mesh->vertices == NULL) {
-        fprintf(stderr, "Error allocating memory\n");
-        exit(1);
-    }
-
-    mesh->triangles = (Triangle *)malloc (sizeof(Triangle) * pmodel->numtriangles);
-    
-    if (mesh->triangles == NULL) {
-        fprintf(stderr, "Error allocating memory\n");
-        exit(1);
-    }
+        int i, e;
+        int v1, v2, v3;
+        float x, y, z;
+        //int *vlist = NULL, j, num;
+        Mesh *mesh;
+#ifdef OUTPUT_SEVERAL_GROUPS
+                int t;
+                int curGroup;
+                GLMgroup *group;
+#endif
+
+                mesh = (Mesh *)malloc (sizeof(Mesh));
+
+                if (mesh == NULL) {
+                        fprintf(stderr, "Error allocating memory\n");
+                        exit(1);
+                }
+
+                mesh->vertices = (Vertex *)malloc (sizeof(Vertex) * pmodel->numvertices);
+                mesh->numVertices = 0;
+
+                if (mesh->vertices == NULL) {
+                        fprintf(stderr, "Error allocating memory\n");
+                        exit(1);
+                }
+
+                mesh->triangles = (Triangle *)malloc (sizeof(Triangle) * pmodel->numtriangles);
+                mesh->numTriangles = 0;
+
+                if (mesh->triangles == NULL) {
+                        fprintf(stderr, "Error allocating memory\n");
+                        exit(1);
+                }
     
     printf("Adding vertices...");
-    for (i=1; i<=(int)pmodel->numvertices; i++) { // Vertices start at 1
-        mesh->vertices[i - 1].x = pmodel->vertices[3 * i + 0];
-        mesh->vertices[i - 1].y = pmodel->vertices[3 * i + 1];
-        mesh->vertices[i - 1].z = pmodel->vertices[3 * i + 2];
-        mesh->vertices[i - 1].numTriangles = 0;
-        mesh->vertices[i - 1].triangles = NULL;
-                                mesh->vertices[i - 1].numEdges = 0;
-        mesh->vertices[i - 1].edges = NULL;
-        mesh->vertices[i - 1].enable = GL_TRUE;
-    }
+                for (i=1; i<=(int)pmodel->numvertices; i++) { // Vertices start at 1
+
+                        x = pmodel->vertices[3 * i + 0];
+                        y = pmodel->vertices[3 * i + 1];
+                        z = pmodel->vertices[3 * i + 2];
+
+                        addVertex(mesh, x, y, z);
+                }
     printf("Ok\n");
-    mesh->numVertices = pmodel->numvertices;
-    mesh->currentNumVertices = pmodel->numvertices;
+    mesh->currentNumVertices = mesh->numVertices;
+    printf("Number of vertices: %d\n", mesh->numVertices);
 
     printf("Adding triangles...");
-
 #ifdef OUTPUT_SEVERAL_GROUPS
     group = pmodel->groups;
     curGroup=0; // current group
-    while(group) {
-        
-        for (i=0; i<(int)group->numtriangles; i++) {
-            
-            t = group->triangles[i];
-
-            mesh->triangles[t].id = t;
-            mesh->triangles[t].group = curGroup; // set group
-            mesh->triangles[t].indices[0] = pmodel->triangles[t].vindices[0] - 1;
-            mesh->triangles[t].indices[1] = pmodel->triangles[t].vindices[1] - 1;
-            mesh->triangles[t].indices[2] = pmodel->triangles[t].vindices[2] - 1;
-            mesh->triangles[t].area = computeTriangleArea(mesh->vertices, &mesh->triangles[t]);
-            //printf("\n%d a: %f",i , mesh->triangles[i].area);
-            computeTriangleNormal(mesh->vertices, &mesh->triangles[t]);
-            
-            mesh->triangles[t].saliency = 0.0;
-            
-            mesh->triangles[t].enable = GL_TRUE;
-            
-            for (j=0; j<3; j++) {
-                // Adding triangle i adjacent to 3 vertices
-                v1 = mesh->triangles[t].indices[j];
-                
-                // Reallocate memory for the new adjacent triangle
-                mesh->vertices[v1].triangles = 
-                                        (int *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(int));
-                addItem((int *)mesh->vertices[v1].triangles, (int *)&mesh->vertices[v1].numTriangles, t);
-            }
-        }
-        curGroup++;
-        group = group->next;
-    }
+                while(group) {
+
+                        for (i=0; i<(int)group->numtriangles; i++) {
+
+                                t = group->triangles[i];
+
+                                v1 = pmodel->triangles[t].vindices[0] - 1;
+                                v2 = pmodel->triangles[t].vindices[1] - 1;
+                                v3 = pmodel->triangles[t].vindices[2] - 1;
+
+                                // not a degenerated triangle
+                                if ((v1 != v2) && (v2 != v3) && (v1 != v3)) {
+
+                                        addTriangle(mesh, curGroup, v1, v2, v3);
+                                }
+                        }
+                        curGroup++;
+                        group = group->next;
+                }
 #else // One single group
-    for (i=0; i<pmodel->numtriangles; i++) {
-        mesh->triangles[i].id = i;
-        mesh->triangles[i].indices[0] = (int)pmodel->triangles[i].vindices[0] - 1;
-        mesh->triangles[i].indices[1] = (int)pmodel->triangles[i].vindices[1] - 1;
-        mesh->triangles[i].indices[2] = (int)pmodel->triangles[i].vindices[2] - 1;
-        mesh->triangles[i].area = computeTriangleArea(mesh->vertices, &mesh->triangles[i]);
-        //printf("\n%d a: %f",i , mesh->triangles[i].area);
-        computeTriangleNormal(mesh->vertices, &mesh->triangles[i]);
-
-        mesh->triangles[i].saliency = 0.0;
-
-        mesh->triangles[i].enable = GL_TRUE;
-        
-        for (j=0; j<3; j++) {
-            // Adding triangle i adjacent to 3 vertices
-            v1 = mesh->triangles[i].indices[j];
-   
-            // Reallocate memory for the new adjacent triangle
-            mesh->vertices[v1].triangles = 
-                            (int *)realloc(mesh->vertices[v1].triangles, (mesh->vertices[v1].numTriangles + 1) * sizeof(int));
-            addItem((int *)mesh->vertices[v1].triangles, (int *)&mesh->vertices[v1].numTriangles, i);
-        }
-    }
+                for (i=0; i<(int)pmodel->numtriangles; i++) {
+
+                        v1 = pmodel->triangles[i].vindices[0] - 1;
+                        v2 = pmodel->triangles[i].vindices[1] - 1;
+                        v3 = pmodel->triangles[i].vindices[2] - 1;
+
+                        // not a degenerated triangle
+                        if ((v1 != v2) && (v2 != v3) && (v1 != v3)) {
+
+                                addTriangle(mesh, 1, v1, v2, v3);
+                        }
+                }
     printf("\n");
 #endif
+                printf("Ok\n");
+                mesh->currentNumTriangles = mesh->numTriangles;
+                printf("Number of triangles: %d\n", mesh->numTriangles);
+                printf("Number of degenerated triangles: %d\n", pmodel->numtriangles - mesh->numTriangles);
+
+                mesh->edges = (Edge *)malloc (sizeof(Edge) * mesh->numTriangles * 3);  // E = 3 T / 2
+                mesh->numEdges = 0;
+
+                if (mesh->edges == NULL) {
+                        fprintf(stderr, "Error allocating memory\n");
+                        exit(1);
+                }
+
+    printf("Adding edges...");
+
+    /*for (i=0; i<mesh->numVertices; i++) {
+        vlist = verticesAdjToVertex(mesh, i, &num);
+        
+        for (j=0; j<num; j++) {
+            
+            if  (i < vlist[j]) {
+                                
+                                addEdge(mesh, i, vlist[j]);
+            }
+        }
+        free(vlist);
+    }*/
+
+                for (i=0; i<mesh->numTriangles; i++) {
+
+                        v1 = mesh->triangles[i].indices[0];
+                        v2 = mesh->triangles[i].indices[1];
+                        v3 = mesh->triangles[i].indices[2];
+
+                        /////////////////////////////////////////////////////////////////////////////////
+                        // edge (v1,v2)
+                        if ((e = findEdge(mesh->edges, mesh->numEdges, v1, v2)) == -1) {
+
+                                addEdge(mesh, v1, v2);
+                        }
+                        /////////////////////////////////////////////////////////////////////////////////
+                        // edge (v2,v3)
+                        if ((e = findEdge(mesh->edges, mesh->numEdges, v2, v3)) == -1) {
+
+                                addEdge(mesh, v2, v3);
+                        }
+                        /////////////////////////////////////////////////////////////////////////////////
+                        // edge (v3,v1)
+                        if ((e = findEdge(mesh->edges, mesh->numEdges, v3, v1)) == -1) {
+
+                                addEdge(mesh, v3, v1);
+                        }
+                }
     printf("Ok\n");
-
-    mesh->numTriangles = pmodel->numtriangles;
-    mesh->currentNumTriangles = pmodel->numtriangles;
-    printf("Number of triangles: %d\n", mesh->numTriangles);
-
-    mesh->edges = (Edge *)malloc (sizeof(Edge) * mesh->numTriangles * 3);  // E = 3 T / 2
-    
-    if (mesh->edges == NULL) {
-        fprintf(stderr, "Error allocating memory\n");
-        exit(1);
-    }
-    
-    printf("Adding edges...");
-    n = 0;
-
-    for (i=0; i<mesh->numTriangles; i++) {
-        t = 0;
-        v1 = mesh->triangles[i].indices[0];
-        v2 = mesh->triangles[i].indices[1];
-        v3 = mesh->triangles[i].indices[2];
-        
-        /////////////////////////////////////////////////////////////////////////////////
-                // edge (v1,v2)
-        if ((e = findEdge(mesh->edges, n, v1, v2)) == -1) {
-            mesh->edges[n].u = v1;
-            mesh->edges[n].v = v2;
-            mesh->edges[n].enable = GL_TRUE;
-            m = n;
-            n++;
-        } else m = e;
-
-        /////////////////////////////////////////////////////////////////////////////////
-        // edge (v2,v3)
-        if (( e = findEdge(mesh->edges, n, v2, v3)) == -1) {
-            mesh->edges[n].u = v2;
-            mesh->edges[n].v = v3;
-            mesh->edges[n].enable = GL_TRUE;
-            m = n;
-            n++;
-        } else m = e;
-
-        /////////////////////////////////////////////////////////////////////////////////
-        // edge (v3,v1)
-        if ((e = findEdge(mesh->edges, n, v3, v1)) == -1) {
-            mesh->edges[n].u = v3;
-            mesh->edges[n].v = v1;
-            mesh->edges[n].enable = GL_TRUE;
-            m = n;
-            n++;
-        } else m = e;
-    }
-    printf("Ok\n");
-    mesh->numEdges = n;
-
-                for (i=0; i<mesh->numEdges; i++) {
-                        v1 = mesh->edges[i].u;
-                        v2 = mesh->edges[i].v;
-
-                        mesh->vertices[v1].edges = 
-                                (int *)realloc(mesh->vertices[v1].edges, (mesh->vertices[v1].numEdges + 1) * sizeof(int));
-                        // Adding edge i adjacent to vertex v1
-                        addItem(mesh->vertices[v1].edges, &mesh->vertices[v1].numEdges, i);
-
-                        mesh->vertices[v2].edges = 
-                                (int *)realloc(mesh->vertices[v2].edges, (mesh->vertices[v2].numEdges + 1) * sizeof(int));
-                        // Adding edge i adjacent to vertex v2
-                        addItem(mesh->vertices[v2].edges, &mesh->vertices[v2].numEdges, i);
-                }
 
     return mesh;

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

@@ -58 +58 @@
 
 double VMI::computeTriangleSaliency(Mesh *mesh, int **histogram, int numCameras, int k) {
-    int i, l, v0, v1, v2;
-    int *triangles = NULL, n = 0;
+    int i, j, t, v0;
+    int n = 0;
     double sal = 0.0;
     
-    v0 = mesh->triangles[k].indices[0];
-    v1 = mesh->triangles[k].indices[1];
-    v2 = mesh->triangles[k].indices[2];
-    
-    /* Allocating memory */
-    triangles = (int *)malloc((mesh->vertices[v0].numTriangles +
-                               mesh->vertices[v1].numTriangles +
-                               mesh->vertices[v2].numTriangles) * sizeof(int));
-
-    for(i=0; i<mesh->vertices[v0].numTriangles; i++) {
-        l = mesh->vertices[v0].triangles[i];
+    for (j=0; j<3; j++) {
         
-        if (l != k) 
-            addItem(triangles, &n, l);
-    }
-    
-    for(i=0; i<mesh->vertices[v1].numTriangles; i++) {
-        l = mesh->vertices[v1].triangles[i];
+        v0 = mesh->triangles[k].indices[j];
         
-        if (l != k) 
-            addItem(triangles, &n, l);
-    }
-    
-    for(i=0; i<mesh->vertices[v2].numTriangles; i++) {
-        l = mesh->vertices[v2].triangles[i];
-        
-        if (l != k) 
-            addItem(triangles, &n, l);
-    }
-    
-    //printItemList(triangles, n);
-    
-    for(i=0; i<n; i++) {
-        //printf("\n%d %d", k, triangles[i]);
-        //sal += computeJS(histogram, numCameras, k, triangles[i]);
-                sal = MAX ( sal, computeJS(histogram, numCameras, k, triangles[i]));
+        for(i=0; i<mesh->vertices[v0].numTriangles; i++) {
+            t = mesh->vertices[v0].triangles[i];
+            
+            if (t != k) {
+                //printf("\n%d %d", k, triangles[i]);
+                //sal += computeJS(histogram, numCameras, k, t);
+                sal = MAX(sal, computeJS(histogram, numCameras, k, t));
+                
+                n++;
+            }
+        }
     }
     //printf("\nT%d Sal: %f\n", k, (sal / n));
     //getchar();
     
-    free(triangles);
-
     return (sal /*/ n*/);
 }