---

VertexJoin.cc

Go to the documentation of this file.

/*
    File:       VertexJoin.cc
    
    Function:   Join up disconnected mesh.
    
    Author:     Andrew Willmott 

    Notes:      Call SetBounds, and then AddVertex to get new ids for the 
                vertices. When finished call GetFinalVertexList() to retrieve
                the new list of vertices.
*/

#include "gcl/VertexJoin.h"
#include <stdio.h>

#define VJ_DBG if (0) printf

Void VertexJoin::Init(const Point &min, const Point &max, Int numVertices)
{
    Int     i, gridSize;
    
    VJ_DBG("Starting init [%d]\n", numVertices);
    vertices = new PointList;
    vertices->PreAllocate(numVertices);
    nextList.SetSize(numVertices);
    idList.SetSize(numVertices);

    SELF.max = max;
    SELF.min = min;
    
    // for now, we hard-code the grid size
    cells[0] = 32;
    cells[1] = 32;
    cells[2] = 32;
    gridSize = cells[0] * cells[1] * cells[2];
    grid = new Int[gridSize];

    for (i = 0; i < gridSize; i++)
        grid[i] = -1;

    for (i = 0; i < numVertices; i++)
        nextList[i] = -1;

    VJ_DBG("done\n");
}

Int VertexJoin::AddVertex(const Point &where, Int id)
{
    Int     vcell[3], *indexPtr;
    Vector  bDelta, delta;
    
    // find cell of the grid.
    
    VJ_DBG("Adding point...\n");
    
    bDelta = max - min;
    delta = where - min;

    VJ_DBG("d1: %g %g %g d2: %g %g %g\n",
        bDelta[0], bDelta[1], bDelta[2], delta[0], delta[1], delta[2]);

    delta /= bDelta; 
    delta *= Vector(cells[0], cells[1], cells[2]);

    VJ_DBG("where: %g %g %g delta: %g %g %g\n",
        where[0], where[1], where[2], delta[0], delta[1], delta[2]);
        
    vcell[0] = (Int) delta[0];
    if (vcell[0] >= cells[0]) vcell[0] = cells[0] - 1;
    vcell[1] = (Int) delta[1];
    if (vcell[1] >= cells[1]) vcell[1] = cells[1] - 1;
    vcell[2] = (Int) delta[2];
    if (vcell[2] >= cells[2]) vcell[2] = cells[2] - 1;

    VJ_DBG("cell %d %d %d from %d %d %d\n", vcell[0], vcell[1], vcell[2],
        cells[0], cells[1], cells[2]);
    indexPtr = grid + (vcell[0] + vcell[1] * cells[0] +
                       vcell[2] * cells[0] * cells[1]);

    // okay, now we search for a vertex match   
    while (*indexPtr >= 0)
    {
        VJ_DBG("index %d\n", *indexPtr);
        // return current index if we match...
        if ((id == idList[*indexPtr]) && 
            MatchVertex(where,  (*vertices)[*indexPtr]))
        {
            VJ_DBG("hit at index %d\n", *indexPtr);
            return(*indexPtr);
        }
            
        // find next entry in linked list...        
        indexPtr = &(nextList[*indexPtr]);
    }
    
    // no match... so add the new vertex.
    
    *indexPtr = vertices->NumItems();
    VJ_DBG("adding new vertex at index %d\n", *indexPtr);
    vertices->Append(where);
    idList[*indexPtr] = id;
    return(*indexPtr);
}


PointList *VertexJoin::GetFinalVertexList()
{
    PointList *result;

    delete grid;
    grid = 0;
    result = vertices;
    vertices = 0;
    idList.SetSize(0);
    nextList.SetSize(0);

    return(result);
}

Bool VertexJoin::MatchVertex(const Point &a, const Point &b)
{
    // hack for now
    const GCLReal   eps = 1e-5;
    
    return(len(a - b) < eps);
}

---