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

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

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

#define MAX_NUM_TRI 250

using namespace VMI;

std::vector<VMI::vmiStep> VMI::mVMISteps;

Change *VMI::createChange (Mesh *mesh, int e) {
    Change *c;
    
    c = (Change*) malloc (sizeof(Change));
    if (NULL == c) {
        fprintf (stderr, "no more memory for mesh changes");
        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;
    
    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 p)
{
        int u = t->indices[0],
                        v = t->indices[1],
                        w = t->indices[2];

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

        return FALSE;
}

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

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

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]);*/
        }
}

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

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

                //printf("Deleting triangle %d\n",t);
                mesh->triangles[t].enable = FALSE;
                mesh->currentNumTriangles--;
        }
}

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

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

                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]);*/

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

int VMI::getTrianglesToModify(Mesh *mesh, int c, int p, Triangle *modified)
{
        GLuint i, num = 0;

        for (i=0; i<mesh->numTriangles; i++)
        {
                if ((mesh->triangles[i].enable == TRUE) && 
                                isATriangleToModify(&mesh->triangles[i], c, p))
                {

                        //printf("Triangle to modify %d\n", i);
                        // Save the original values of the triangle
                        memcpy(&modified[num], &mesh->triangles[i], sizeof(Triangle));
                        num++;
                }
        }

        return num;
}

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

int VMI::getTrianglesToDelete(Mesh *mesh, int numMod, Triangle *modified, Triangle *deleted, int c, int p)
{
        int i, num = 0;
        GLuint t;

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

                if (isATriangleToDelete(&mesh->triangles[t], c, p))
                {                                             
                        //printf("Triangle to delete %d\n",t);                    
                        memcpy(&deleted[num], &modified[i], sizeof(Triangle));
                        num++;
                }
        }
        return num;
}

void VMI::printList(Triangle *list, int n)
{
        int i;

        for (i=0; i<n; i++)
                printf("%d ",list[i].id);

        printf("\n");
}

void VMI::deleteItem(Triangle *list, int *n, int item)
{
        int i, j;

        for (i=0; i<*n; i++)
        {
                if (list[i].id == (GLuint)item)
                {
                        // delete it
                        for (j =i + 1 ; j<*n; j++)
                                list[j - 1] = list[j];
                        (*n)--;
                        i--; // Delete all ocurrencies of an item
                }
        }
}

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

// Compute the triangle mesh changes due to a heap node simplification
void VMI::computeChanges(Mesh *mesh, Change *c)
{
        Triangle m[MAX_NUM_TRI], d[MAX_NUM_TRI/2];
        int numMod = getTrianglesToModify(mesh, c->u, c->v, m);
        int numDel = getTrianglesToDelete(mesh, numMod, m, d, c->u, c->v);
        int i;

        //printf("d %d\n",numDel);
        //printList(d, numDel);

        for (i=0; i<numDel; i++)
                deleteItem(m, &numMod, d[i].id);

        //printf("m %d\n",numMod);
        //printList(m, numMod);
        //getchar();

        c->numDel = numDel;
        // Free memory
        if (c->deleted != NULL) free(c->deleted);
        // Allocate memory
        c->deleted = (Triangle *)malloc(sizeof(Triangle) * numDel);
        
        if (c->deleted == NULL)
        {
                fprintf(stderr, "Error allocating memory\n");
                exit(1);
        }
        
        memcpy(c->deleted, d, sizeof(Triangle) * numDel);

        c->numMod = numMod;
        
        // Free memory
        if (c->modified != NULL) free(c->modified);
        
        // Allocate memory
        c->modified = (Triangle *)malloc(sizeof(Triangle) * numMod);
        
        if (c->modified == NULL)
        {
                fprintf(stderr, "Error allocating memory\n");
                exit(1);
        }
        
        memcpy(c->modified, m, sizeof(Triangle) * numMod);

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

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

        deleteTriangles(mesh, c);

        mesh->vertices[c->u].enable = FALSE;
        mesh->currentNumVertices--;
}

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

        undeleteTriangles(mesh, c);

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

//      Save simplification sequence in Geometry Game Tools format.
extern void     VMI::saveSimplificationSequence(Change  *c)
{
        vmiStep step;
        step.mV0        =       c->u;
        step.mV1        =       c->v;

        //      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 =       0;

        //      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.
        mVMISteps.push_back(step);
}