Changeset 2127 for GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/simplify.cpp

Timestamp:

02/19/07 09:16:59 (17 years ago)

Author:

gumbau

Message:

 

File:

• GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/simplify.cpp (modified) (24 diffs)

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

@@ -10 +10 @@
 #include "../include/saliency.h"
 #include "../include/histogram.h"
+#include "../include/buffers.h"
 
 //#define RECOMPUTE_THE_WHOLE_HEAP
@@ -59 +60 @@
 
 bheap_t *VMI::initHeap(Mesh *mesh) {
-        GLuint i;
+        int i;
         double cost;
         bheap_t *h = NULL;
@@ -152 +153 @@
 
         return h;
-}
-
-GLdouble VMI::computeEdgeLength(Vertex *vertices, int u, int v) {
-        GLfloat ux, uy, uz, vx, vy ,vz, rx, ry, rz;
-
-        ux = vertices[u].x;
-        uy = vertices[u].y;
-        uz = vertices[u].z;
-
-        vx = vertices[v].x;
-        vy = vertices[v].y;
-        vz = vertices[v].z;
-
-        rx = ux - vx;
-        ry = uy - vy;
-        rz = uz - vz;
-
-        return sqrt((rx * rx) + (ry * ry) + (rz * rz));
 }
 
@@ -243 +226 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-void saveProjectedAreas(GLuint **histogram, GLuint numCameras, Change *c, GLuint *dest) {
-        GLuint i, j, t, n = 0;
-
-        for (j=0; j<(GLuint)c->numDel; j++) {
+void saveProjectedAreas(int **histogram, int numCameras, Change *c, int *dest) {
+        int i, j, t, n = 0;
+
+        for (j=0; j<c->numDel; j++) {
 
                 t = c->deleted[j].id;
@@ -257 +240 @@
         }
 
-        for (j=0; j<(GLuint)c->numMod; j++) { 
+        for (j=0; j<c->numMod; j++) { 
 
                 t = c->modified[j].id;
@@ -276 +259 @@
 }
 
-void loadProjectedAreas(GLuint *src, GLuint numCameras, Change *c, GLuint **histogram) {
-        GLuint i, j, t, n = 0;
-
-        for (j=0; j<(GLuint)c->numDel; j++) { 
+void loadProjectedAreas(int *src, int numCameras, Change *c, int **histogram) {
+        int i, j, t, n = 0;
+
+        for (j=0; j<c->numDel; j++) { 
 
                 t = c->deleted[j].id;
@@ -290 +273 @@
         }
 
-        for (j=0; j<(GLuint)c->numMod; j++) { 
+        for (j=0; j<c->numMod; j++) { 
 
                 t = c->modified[j].id;
@@ -308 +291 @@
         }
 }
-
 ///////////////////////////////////////////////////////////////////////////////
+#ifdef CHECK_LOCAL_INVERSION
+int check_local_inversion(Mesh *mesh, Change *c) {
+    int i, t;
+    int v0, v1, v2;
+    double vol_before;
+    double vol_after;
+    Triangle tri;
+    
+    for(i=0; i<mesh->vertices[c->u].numTriangles; i++) {
+        
+        t = mesh->vertices[c->u].triangles[i];
+        
+        v0 = mesh->triangles[t].indices[0];
+        v1 = mesh->triangles[t].indices[1];
+        v2 = mesh->triangles[t].indices[2];
+        
+        if ((v0 != c->v) && (v1 != c->v) && (v2 != c->v)) {
+            
+            //printf("%d\n", t);
+            memcpy(&tri, &mesh->triangles[t], sizeof(Triangle));
+            
+            vol_before = computeTriangleVolume(mesh->vertices, &tri);
+
+            //printf("t:[%d,%d,%d]\n", tri.indices[0], tri.indices[1], tri.indices[2]);
+            //printf("v:%f\n", vol_before);
+          
+            if (tri.indices[0] == c->u) tri.indices[0] = c->v;
+            if (tri.indices[1] == c->u) tri.indices[1] = c->v;
+            if (tri.indices[2] == c->u) tri.indices[2] = c->v;
+            
+            vol_after = computeTriangleVolume(mesh->vertices, &tri);
+
+            //printf("t:[%d,%d,%d]\n", tri.indices[0], tri.indices[1], tri.indices[2]);
+            //printf("v:%f\n", vol_after);
+
+            if (((vol_before > 0) && (vol_after < 0)) || 
+                ((vol_before < 0) && (vol_after > 0)))
+
+                return TRUE;
+        }
+    }
+    return FALSE;
+}
+#endif
 
 GLdouble VMI::computeEdgeCost(Mesh *mesh, int e) {
@@ -318 +344 @@
         GLdouble newI;
 #endif
-        GLuint i, *histoAux = NULL;
+        int i, *histoAux = NULL;
         Change *c;
+#if defined(VERTEX_BUFFER_OBJECTS) || defined(VERTEX_ARRAY)
+    VertexIL *vb = NULL;
+#endif
+#ifdef CHECK_LOCAL_INVERSION
+    int penalized;
+#endif
 
         chooseBestEndPoints(mesh, e);
@@ -327 +359 @@
 
         // Compute cost only for boundary or manifold edges
-        if (c->numDel == 2
-                        /*(c->numDel <3) && (c->numDel > 0)*/) {
+        if (/*c->numDel == 2*/
+                        (c->numDel <3) && (c->numDel > 0)) {
+
+#ifdef CHECK_LOCAL_INVERSION
+        penalized = check_local_inversion(mesh, c);
+#endif
                 // Allocate memory
-                histoAux = (GLuint *)malloc((c->numDel + c->numMod + 1) * numCameras * sizeof(GLuint));
+                histoAux = (int *)malloc((c->numDel + c->numMod + 1) * numCameras * sizeof(int));
+
+#if defined(VERTEX_BUFFER_OBJECTS) || defined(VERTEX_ARRAY)
+        vb = (VertexIL *)malloc((c->numDel + c->numMod + 1) * 3 * sizeof(VertexIL));
+
+        saveVertexBuffer(c, vb);
+#endif
 
 #ifdef MI // Mutual Information
@@ -365 +407 @@
                         //printf("  I0:%f Is: %f\n", auxE[i], initialIs[i]);
 
-                        cost += (ABS(auxIs[i] - initialIs[i]) * cameras[i].weight * sal);
+                        cost += (ABS(auxIs[i] - initialIs[i]) * cameras[i].weight);
 
                         // Restore old informations
@@ -405 +447 @@
                         newI = computeCS(mesh, histogram[i]);
 #endif
-                        cost += (ABS(initialIs[i] - newI) * cameras[i].weight * sal);
+                        cost += (ABS(initialIs[i] - newI) * cameras[i].weight);
                 }
                 undoChange(mesh, c);
@@ -417 +459 @@
                 // Free memory
                 free(histoAux);
+#if defined(VERTEX_BUFFER_OBJECTS) || defined(VERTEX_ARRAY)
+        loadVertexBuffer(vb, c);
+        free(vb);
+#endif
+#ifdef CHECK_LOCAL_INVERSION
+        if (penalized) cost *= 5;
+#endif
 
         } else cost = FLT_MAX;
@@ -422 +471 @@
         deleteChange(c);
 
-        return cost;
-}
+        return (cost * sal);
+}
+
+int isValidEdge_(Mesh *mesh, int e) {
+    int u , v;
+
+    if (mesh->edges[e].enable == FALSE) return FALSE;
+    else {
+        u = mesh->edges[e].u;
+        v = mesh->edges[e].v;
+
+        if (u == v) {
+
+            mesh->edges[e].enable = FALSE;
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
 /* Get a valid edge from the heap */
 int getMinValidEdge(Mesh *mesh, bheap_t *h) {
@@ -431 +499 @@
         e = bh_min(h);
 
-        while (mesh->edges[e].enable == FALSE) {
+        while (!isValidEdge_(mesh, e)) {
                 /* delete invalid edge */
                 bh_delete(h, e);
@@ -473 +541 @@
 
 ///////////////////////////////////////////////////////////////////////////
-void VMI::simplifyModel(Mesh *mesh, GLuint numDemandedTri)
+void VMI::simplifyModel(Mesh *mesh, int numDemandedTri)
 {
         int                     e;
@@ -558 +626 @@
                 bh_delete(h, e);
 
+                updateHWAcceleration(c);
+
                 // Get projected areas after the edge collapse
                 getProjectedAreas(histogram, numCameras);
@@ -563 +633 @@
                 computeCameraIs(histogram, numCameras, initialIs);
 
-                deleteEdges(mesh, c);
-                modifyEdges(mesh, c);
+                updateEdgeAdj(mesh, c);
+
+    modifyEdges(mesh, c);
 
                 // Update the heap according to the edge collapse
@@ -751 +822 @@
 
         Edge            *econ;
-        float           x,y,z;
         int                     *lv1;
         int                     v0;
@@ -797 +867 @@
                         v1      =       (*lb1).second;
 
-                        lv1     =       edgesAdjToVertex(mesh,v1,&num_edges);
+                        lv1     =       mesh->vertices[v1].edges;
+                        num_edges = mesh->vertices[v1].numEdges;
 
                         //      Edje iterator.
@@ -857 +928 @@
 
                         deleteVertexOfMap(mesh, c->u);
-                        deleteEdges(mesh, c);
-                        modifyEdges(mesh, c);
+                        updateEdgeAdj(mesh, c);
+      modifyEdges(mesh, c);
                         deleteChange(c);
 
@@ -910 +981 @@
                         lonely_vert     =       (*it).second;
 
-                        le      =       edgesAdjToVertex(mesh,lonely_vert,&num_edges);
+                        le      =       mesh->vertices[lonely_vert].edges;
+
+                        num_edges = mesh->vertices[lonely_vert].numEdges;
 
                         //      Find an edge width v coordinates.
@@ -977 +1050 @@
 
                                 deleteVertexOfMap(mesh, c->u);
-                                deleteEdges(mesh, c);
-                                modifyEdges(mesh, c);
+                                updateEdgeAdj(mesh, c);
+        modifyEdges(mesh, c);
                                 deleteChange(c);
                         }
@@ -1069 +1142 @@
 
                                 deleteVertexOfMap(mesh, c->u);
-                                deleteEdges(mesh, c);
-                                modifyEdges(mesh, c);
+                                updateEdgeAdj(mesh, c);
+        modifyEdges(mesh, c);
                                 deleteChange(c);
                         }