source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/change.cpp @ 2090

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#include "../include/global.h"
#include "../include/change.h"

using namespace VMI;
using namespace std;

Geometry::MeshSimplificationSequence *VMI::mSequence    =       NULL;

Change *VMI::createChange(Mesh *mesh, int e) {
        Change *c;

        c = (Change*) malloc (sizeof(Change));
        if (NULL == c) {
                fprintf (stderr, "no more memory for a mesh change\n");
                exit(1);
        }
        c->e = e;
        c->u = mesh->edges[e].u;
        c->v = mesh->edges[e].v;
        c->modified = NULL;
        c->deleted = NULL;
        c->numDel = 0;
        c->numMod = 0;

        computeChange(mesh, c);

        return c;
}

Change *VMI::newChange(Mesh *mesh, int u, int v) {
        Change *c;

        c = (Change*) malloc (sizeof(Change));
        if (NULL == c) {
                fprintf (stderr, "no more memory for a mesh change\n");
                exit(1);
        }
        c->e = -1; // Default edge, not used
        c->u = u;
        c->v = v;
        c->modified = NULL;
        c->deleted = NULL;
        c->numDel = 0;
        c->numMod = 0;

        computeChange(mesh, c);

        return c;
}

void VMI::deleteChange(Change *c)
{

        if (NULL != c)
        {
                if (c->deleted != NULL)   free(c->deleted);
                if (c->modified != NULL)  free(c->modified);
                c->modified = NULL;
                c->deleted = NULL;
                c->numDel = 0;
                c->numMod = 0;

                free(c);
                c = NULL;
        }
}

void VMI::writeChange(FILE* file, Change *c)
{
        int i;

        fputc('v',file);
        fputc('%',file);
        fprintf(file, " %d %d 0 0 0 ", c->v, c->u);

        for (i=0; i<c->numDel; i++) {
                fprintf(file, "%d ", c->deleted[i].id);
        }

        fputc('&',file);
        for (i=0; i<c->numMod; i++) {
                fprintf(file, " %d", c->modified[i].id);
        }

        fputc('\n',file);
}

void VMI::printChange(Change *c)
{
        int i;

        if (NULL != c) {

                printf("e%d(%d,%d)\n",c->e,c->u,c->v);

                printf("d %d\n", c->numDel);
                for (i=0;i<c->numDel;i++) {
                        printf(" %d", c->deleted[i].id);
                }
                printf("\n");
                printf("m %d\n", c->numMod);
                for (i=0;i<c->numMod;i++) {
                        printf(" %d", c->modified[i].id);
                }
                printf("\n");
        }
}

void VMI::modifyTriangle(Triangle *t, int c, int p)
{
        if ((int)t->indices[0] == c)
                t->indices[0]= p;
        if ((int)t->indices[1] == c)
                t->indices[1]= p;
        if ((int)t->indices[2] == c)
                t->indices[2]= p;
}

int VMI::isATriangleToModify(Triangle *t, int c)
{
        int u = t->indices[0],
                        v = t->indices[1],
                        w = t->indices[2];

        if ((u == c) || (v == c) || (w == c)) return TRUE;

        return FALSE;
}

int VMI::isATriangleToDelete(Triangle *t, int c, int p)
{
        int u = t->indices[0],
                        v = t->indices[1],
                        w = t->indices[2];

        if (((u == c) && ( v == p)) ||
                        ((u == c) && ( w == p)) || 
                        ((v == c) && ( w == p)))
                return TRUE;
        if (((u == p) && ( v == c)) ||
                        ((u == p) && ( w == c)) || 
                        ((v == p) && ( w == c)))
                return TRUE;

        return FALSE;
}

void VMI::modifyTriangles(Mesh *mesh, Change *c)
{
        int i, t;

        // Reallocate memory for new adjacent triangles from vertex v
  if (c->numMod > 0) {
      mesh->vertices[c->v].triangles = 
          (GLuint *)realloc(mesh->vertices[c->v].triangles, 
          (mesh->vertices[c->v].numTriangles + mesh->vertices[c->u].numTriangles) * sizeof(GLuint));
  }

        for (i=0; i<c->numMod; i++) {
                t = c->modified[i].id;
                modifyTriangle(&mesh->triangles[t], c->u, c->v);

                //printf("New area of triangle %d:\n", t);
                mesh->triangles[t].area = computeTriangleArea(mesh->vertices, &mesh->triangles[t]);

                computeTriangleNormal(mesh->vertices, &mesh->triangles[t]);

                // Update vertex adjacency c->v
                addItem((int *)mesh->vertices[c->v].triangles, (int *)&mesh->vertices[c->v].numTriangles, t);
        }
}

void VMI::unmodifyTriangles(Mesh *mesh, Change *c)
{
        int i, t;

        for (i=0; i<c->numMod; i++) {
                t = c->modified[i].id;

                memcpy(&mesh->triangles[t], &c->modified[i], sizeof(Triangle));
                /*printf("t(%d %d %d)\n", mesh->triangles[t].indices[0], 
                        mesh->triangles[t].indices[1],
                        mesh->triangles[t].indices[2]);*/

                // Update vertex adjacency c->v
                delItem((int *)mesh->vertices[c->v].triangles, (int *)&mesh->vertices[c->v].numTriangles, t);
        }

}

int VMI::hasEdge(Triangle *t, int e) {
    int e0 = t->edges[0],
        e1 = t->edges[1],
        e2 = t->edges[2];
    
    if ((e == e0) || (e == e1) || (e == e2)) return TRUE;

    return FALSE;
}

void VMI::getEdges(Triangle *t, Change *c, int *l, int *r) {

    // Default edges
    *l = -1;
    *r = -1;

    // Set edge l and r
    if ((int)t->edges[0] == c->e) {
        *l = t->edges[1];
        *r = t->edges[2];
        if ((int)mesh->edges[*l].u == c->v || (int)mesh->edges[*l].v == c->v)
            swap(l, r);
    } else if ((int)t->edges[1] == c->e) {
        *l = t->edges[0];
        *r = t->edges[2];
        if ((int)mesh->edges[*l].u == c->v || (int)mesh->edges[*l].v == c->v)
            swap(l, r);
    } else if ((int)t->edges[2] == c->e) {
        *l = t->edges[0];
        *r = t->edges[1];
        if ((int)mesh->edges[*l].u == c->v || (int)mesh->edges[*l].v == c->v)
            swap(l, r);
    }
}

void VMI::swap(int *i, int *j) {
    int t;

    t = *i;
    *i = *j;
    *j = t;
}

void VMI::deleteTriangles(Mesh *mesh, Change *c)
{
            int i, j, t, v;
#ifdef USE_EDGE_ADJACENCY
    int t1, l, r;
#endif
    
    for (i=0; i<c->numDel; i++) {
        t = c->deleted[i].id;

        //printf("%d(%d,%d) Deleting triangle %d\n",c->e, c->u, c->v, t);

        // Update vertex adjacency
        for (j=0; j<3; j++) {
            v = c->deleted[i].indices[j];
            
            delItem((int *)mesh->vertices[v].triangles,(int *)&mesh->vertices[v].numTriangles,t);
        }

#ifdef USE_EDGE_ADJACENCY
        // Update triangle edge adjancency
        // The modified triangles have to be calculated before
        // Set edge l and r
        getEdges(&c->deleted[i], c, &l, &r);
        //printf("e%d(%d,%d): l:%d r:%d\n", c->e, c->u, c->v, l, r);
        // Find triangle that contains edge l
        for (j=0; j<c->numMod; j++)
            if (hasEdge(&c->modified[j], l)) {
                // Change edge l by r in the Mesh
                t1 = c->modified[j].id;
                //printf("t:%d %d %d %d\n", t1, mesh->triangles[t1].edges[0], mesh->triangles[t1].edges[1] ,mesh->triangles[t1].edges[2]);
                if (mesh->triangles[t1].edges[0] == (GLuint)l) mesh->triangles[t1].edges[0] = r;
                if (mesh->triangles[t1].edges[1] == (GLuint)l) mesh->triangles[t1].edges[1] = r;
                if (mesh->triangles[t1].edges[2] == (GLuint)l) mesh->triangles[t1].edges[2] = r;
                //printf("t:%d %d %d %d\n", t1, mesh->triangles[t1].edges[0], mesh->triangles[t1].edges[1] ,mesh->triangles[t1].edges[2]);
                break;
            }

        // Delete edge l
        if (l != -1) mesh->edges[l].enable = FALSE;
#endif
        mesh->triangles[t].enable = FALSE;
        mesh->currentNumTriangles--;
    }
}

void VMI::undeleteTriangles(Mesh *mesh, Change *c) {
    int i, j, t, v;
    
    for (i=0; i<c->numDel; i++) {
        t = c->deleted[i].id;
        
        //printf("Undeleting triangle %d\n",t);

        memcpy(&mesh->triangles[t], &c->deleted[i], sizeof(Triangle));
        /*printf("t(%d %d %d)\n", mesh->triangles[t].indices[0], 
                                  mesh->triangles[t].indices[1], 
                                  mesh->triangles[t].indices[2]);*/

        // Update vertex adjacency
        for (j=0; j<3; j++) {
            v = c->deleted[i].indices[j];
            
            addItem((int *)mesh->vertices[v].triangles,(int *)&mesh->vertices[v].numTriangles,t);
        }
#ifdef USE_EDGE_ADJACENCY
        // Enable adjacent edges
        for (j=0; j<3; j++) {
            mesh->edges[mesh->triangles[t].edges[j]].enable = TRUE;
        }
#endif
        mesh->triangles[t].enable = TRUE;
        mesh->currentNumTriangles++;
    }
}

Triangle *VMI::getTrianglesToModify(Mesh *mesh, Change *c, GLuint *numMod) {
  int i, t;
  Triangle *modified = NULL;

  // Allocating memory
  modified = (Triangle *)malloc(mesh->vertices[c->u].numTriangles * sizeof(Triangle));
  *numMod = 0;
  
  for (i=0; i<(int)mesh->vertices[c->u].numTriangles; i++) {
      
      t = mesh->vertices[c->u].triangles[i];
      
      if ((mesh->triangles[t].enable == TRUE) && 
          !isATriangleToDelete(&mesh->triangles[t], c->u, c->v)) {
          
          //printf("Triangle to modify %d\n", t);
          // Save the original values of the triangle
          memcpy(&modified[*numMod], &mesh->triangles[t], sizeof(Triangle));
          (*numMod)++;
      }
  }
  return modified;
}

Triangle *VMI::getTrianglesToDelete(Mesh *mesh, Change *c, GLuint *numDel) {
  int i, t;
  Triangle *deleted = NULL;
  
  // Allocating memory
  deleted = (Triangle *)malloc(mesh->vertices[c->u].numTriangles * sizeof(Triangle));
  *numDel = 0;

  for (i=0; i<(int)mesh->vertices[c->u].numTriangles; i++) {
      
      t = mesh->vertices[c->u].triangles[i];

      if ((mesh->triangles[t].enable == TRUE) &&
          isATriangleToDelete(&mesh->triangles[t], c->u, c->v)) {
                                                    
          //printf("Triangle to delete %d\n",t);                    
          memcpy(&deleted[*numDel], &mesh->triangles[t], sizeof(Triangle));
          (*numDel)++;
      }
  }
  return deleted;
}

void VMI::deleteEdges(Mesh *mesh, Change *c) {
    int i, e;
#ifndef USE_EDGE_ADJACENCY
    int n0, n1, n2;
#else
    int j, u, v;
#endif

#ifdef USE_EDGE_ADJACENCY
    for (i=0; i<c->numDel; i++) {
        
        for (j=0; j<3; j++) {
            e = c->deleted[i].edges[j];
            if (e != c->e) {
                u = mesh->edges[e].u;
                v = mesh->edges[e].v;
                if (u == c->u || v == c->u) {
                    //printf("%d\n",j);
                    mesh->edges[e].enable = FALSE;
                }
            }
        }
        //getchar();
    }
#else
    for (i=0; i<c->numDel; i++) {

        n0 = c->deleted[i].indices[0];
        n1 = c->deleted[i].indices[1];
        n2 = c->deleted[i].indices[2];

        if ((n0 == c->u && n1 != c->v) || (n1 == c->u && n0 != c->v)) {
            e = findEdge(mesh->edges, mesh->numEdges, n0, n1);

            //printf("a\n");
            if (e != -1)
                mesh->edges[e].enable = FALSE;
        }

        if ((n1 == c->u && n2 != c->v) || (n2 == c->u && n1 != c->v)) {
            e = findEdge(mesh->edges, mesh->numEdges, n1, n2);
            
            //printf("b\n");
            if (e != -1)
                mesh->edges[e].enable = FALSE;
        }

        if ((n0 == c->u && n2 != c->v) || (n2 == c->u && n0 != c->v)) {
            e = findEdge(mesh->edges, mesh->numEdges, n0, n2);
            
            //printf("c\n");
            if (e != -1)
                mesh->edges[e].enable = FALSE;
        }
        //getchar();
    }
#endif
}

void VMI::modifyEdges(Mesh *mesh, Change *c) {
    int e, u, v;
    
    // Update mesh and heap
    for(e = 0; e < (int)mesh->numEdges; e++) {
        
        if (mesh->edges[e].enable == TRUE) {
            
            // Modify edge
            if ((int)mesh->edges[e].u == c->u)
                mesh->edges[e].u = c->v;
            
            if ((int)mesh->edges[e].v == c->u)
                mesh->edges[e].v = c->v;
            
            // Check edge
            u = mesh->edges[e].u;
            v = mesh->edges[e].v;
            
            // if the edge is not valid, we simply delete it
            if ((u == v) || 
                (u == c->u) || (v == c->u)) 
                
                mesh->edges[e].enable = FALSE;
        }
    }
}

///////////////////////////////////////////////////////////////////////////////

// Compute the triangle mesh changes due to a heap node simplification
void VMI::computeChange(Mesh *mesh, Change *c) {
  GLuint numMod, numDel;
  Triangle *m = getTrianglesToModify(mesh, c, &numMod),
            *d = getTrianglesToDelete(mesh, c, &numDel);
  
  c->numDel   = numDel;
  c->deleted  = d;
  
  c->numMod   = numMod;
  c->modified = m;

  //printChange(c);
  //getchar();
}

// Update the triangle mesh due to a heap node simplification
void VMI::doChange(Mesh *mesh, Change *c)
{
        modifyTriangles(mesh, c);

        // This function must be called after modifyTriangles()
        deleteTriangles(mesh, c);

        // Delete vertex u
        mesh->vertices[c->u].enable = FALSE;
        mesh->currentNumVertices--;

        //printMesh(mesh);
        //getchar();
}

void VMI::undoChange(Mesh *mesh, Change *c)
{
        unmodifyTriangles(mesh, c);

        undeleteTriangles(mesh, c);

        mesh->vertices[c->u].enable = TRUE;
        mesh->currentNumVertices++;

        //printMesh(mesh);
        //getchar();
}

/*
namespace VMI{
std::map<int, INTVECTOR> inversemap;
}
*/

//      Save simplification sequence in Geometry Game Tools format.
extern void     VMI::saveSimplificationSequence(Change  *c,int obligatory)
{
        Geometry::MeshSimplificationSequence::Step      step;

        if (mSequence == NULL)
        {
                mSequence       =       new Geometry::MeshSimplificationSequence();
        }

        step.mV0        =       c->v;
        step.mV1        =       c->u;

        //      Debug.
        cout    <<      "----> V0: "
                                <<      step.mV0
                                <<      " V1: "
                                <<      step.mV1
                                <<      endl;

        //      If only one triangle has been deleted.
        if (c->numDel == 1)
        {
                step.mT0        =       c->deleted[0].id;
                step.mT1        =       c->deleted[0].id;
        }
        //      If two triangles have been deleted.
        else
        {
                step.mT0        =       c->deleted[0].id;
                step.mT1        =       c->deleted[1].id;
        }

        step.x  =       0.0;
        step.y  =       0.0;
        step.z  =       0.0;

        //      Write obligatory field.
        step.obligatory =       obligatory;

        //      List of new triangles.
        //      For each modified triangle.
        for (int        i = 0;  i < c->numMod;  i++)
        {
                step.mModfaces.push_back(c->modified[i].id);
        }

        //      Add step to list of changes.
        mSequence->mSteps.push_back(step);
}