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

#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 = 
          (int *)realloc(mesh->vertices[c->v].triangles, 
          (mesh->vertices[c->v].numTriangles + mesh->vertices[c->u].numTriangles) * sizeof(int));
  }

        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);
        }

}

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;
    
    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);
        }

        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);
        }

        mesh->triangles[t].enable = TRUE;
        mesh->currentNumTriangles++;
    }
}

Triangle *VMI::getTrianglesToModify(Mesh *mesh, Change *c, int *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, int *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::modifyEdges(Mesh *mesh, Change *c) {
    int i, e;

        for(i = 0; i < mesh->vertices[c->v].numEdges; i++) {
        
                e = mesh->vertices[c->v].edges[i];

        if (mesh->edges[e].enable == TRUE) {
            
            // Modify edge
            if (mesh->edges[e].u == c->u)
                mesh->edges[e].u = c->v;
            
            if (mesh->edges[e].v == c->u)
                mesh->edges[e].v = c->v;
        }
    }
}

int VMI::find(int *edges, int num, int v_) {
        int i;

        int u, v;


        for(i=0; i<num; i++) {

                u = mesh->edges[edges[i]].u;

                v = mesh->edges[edges[i]].v;

                if (u == v_ || v == v_) return TRUE;

        }

        return FALSE;
}
void VMI::updateEdgeAdj(Mesh *mesh, Change *c) {
        int i;

        int v, e;

        mesh->vertices[c->v].edges = 
            (int *)realloc(mesh->vertices[c->v].edges, 
            (mesh->vertices[c->v].numEdges + mesh->vertices[c->u].numEdges) * sizeof(int));

        for (i=0; i<mesh->vertices[c->u].numEdges; i++) {
        
                e = mesh->vertices[c->u].edges[i];
                if (mesh->edges[e].u == c->u) v =mesh->edges[e].v;
                else v = mesh->edges[e].u;
                
                if (!find(mesh->vertices[c->v].edges, mesh->vertices[c->v].numEdges, v))
                        addItem(mesh->vertices[c->v].edges, &mesh->vertices[c->v].numEdges, e);
                else mesh->edges[e].enable = FALSE;
        }

        delItem(mesh->vertices[c->v].edges, &mesh->vertices[c->v].numEdges, c->e);
}

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

// Compute the triangle mesh changes due to a heap node simplification
void VMI::computeChange(Mesh *mesh, Change *c) {
  int 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);
}