---

MRVertex.cc

Go to the documentation of this file.

/*
    File:       MRVertex.cc

    Function:   Implements multi-res vertices used in edge contractions

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/MRVertex.h"
#include "gcl/MRModel.h"
#include "gcl/VecUtil.h"
#include <stdio.h>

// use tree codes to speed things up for the simpler models
//#define GCL_MR_USE_TREECODE

MRVertex::MRVertex() : 
    parent(-1),
    level(0)
{
    child[0] = -1;
    child[1] = -1;
    face[0] = -1;
    face[1] = -1;
}

Void MRVertex::SetContraction(
                    MRVertexes      &vertices,
                    Int             iv,
                    MRFlagsList     &flags,
                    Int             child0,
                    Int             child1,
                    Int             face0,
                    Int             face1,
                    GCLReal         err
                )
{
    MRVertex    &cv0 = vertices[child0], &cv1 = vertices[child1];

    Assert(IsRoot(), "Setting already contracted vertex");
    flags[iv].Set(MRV_Inside);

    child[0] = child0;
    child[1] = child1;
    face[0] = face0;
    face[1] = face1;

    Assert(cv0.IsRoot(), "child[0] already contracted!");
    Assert(cv1.IsRoot(), "child[1] already contracted!");
    cv0.parent = iv;
    cv1.parent = iv;
}

Void MRVertex::PrintID()
{
    printf("v: level %d", level);
//  if (flags.IsSet(MRV_Inside))
//      printf(" [inside]");
//  if (flags.IsSet(MRV_Active))
//      printf(" [active]");
    if (IsLeaf())
        printf(" [leaf]");
    if (IsRoot())
        printf(" [root]");
    printf("\n");
}

Bool MRVertex::CanContract(Int iv, MRFlagsList &flags)
{
    if (IsLeaf())
        return(false);
    else
        return(
            flags[child[0]].IsSet(MRV_Active) &&
            flags[child[1]].IsSet(MRV_Active)
        );
}

Bool MRVertex::CanExpand(Int iv, MRFlagsList &flags)
{
    return(!IsLeaf() && flags[iv].IsSet(MRV_Active));
}

Void MRVertex::Contract(Int iv, MRFlagsList &flags)
{
    Assert(flags[child[0]].IsSet(MRV_Active) && flags[child[1]].IsSet(MRV_Active),
        "contraction children are not active");
    Assert(!flags[iv].IsSet(MRV_Active) && flags[iv].IsSet(MRV_Inside),
        "contraction target is active or not inside");

    flags[iv].Set(MRV_Active);  
    flags[iv].UnSet(MRV_Inside);

    flags[child[0]].UnSet(MRV_Active);
    flags[child[1]].UnSet(MRV_Active);
    
    if (face[0] >= 0)
        flags[face[0]].UnSet(MRV_FaceActive);
    if (face[1] >= 0)
        flags[face[1]].UnSet(MRV_FaceActive);
}

Void MRVertex::Expand(Int iv, MRFlagsList &flags)
{
    flags[iv].UnSet(MRV_Active);    
    flags[iv].Set(MRV_Inside);  

    flags[child[0]].Set(MRV_Active);    
    flags[child[1]].Set(MRV_Active);
    
    if (face[0] >= 0) 
        flags[face[0]].Set(MRV_FaceActive);
    if (face[1] >= 0)
        flags[face[1]].Set(MRV_FaceActive);
}

Void MRSetupHierarchy(
        MRVertexes      &vertices, 
        Int             iv,
        TreeCodes       &treeCodes,
        Int             &height,
        Int             level,
        Int             treeCode
    )
{
    MRVertex    &v = vertices[iv];

    v.level = level;

    if (!v.IsLeaf())
    {
        if (level >= 32)
            treeCode = 0xDEAD;
        
        MRSetupHierarchy(vertices, v.child[0],
            treeCodes, height, level + 1, treeCode);

        if (level < 32)
            treeCode = treeCode | (1 << level);
        
        MRSetupHierarchy(vertices, v.child[1],
            treeCodes, height, level + 1, treeCode);
    }
    else 
    {
        if (height <= level)
            height = level + 1;

        treeCodes[iv] = treeCode;
    }
}

Void MRVertex::PullProps(MRVertexes &vertices)
{
    if (IsLeaf())
        return;
        
    vertices[child[0]].PullProps(vertices);
    vertices[child[1]].PullProps(vertices);
    
    areaNormal = vertices[child[0]].areaNormal + vertices[child[1]].areaNormal;
}

// --- MRCodes methods ------------------------------------------------------

MRCodes::MRCodes()
{
}

Void MRCodes::AdjustVertices(MRVertexes &vertices, MRFlagsList &flags, 
                    Int faceIndexes[3], Int leafIndexes[3])
{
    Int         i, j;

    for (i = 0; i < 3; i++)
    {
        j = faceIndexes[i];

        if (flags[j].IsSet(MRV_Inside))
        {
#ifdef GCL_MR_USE_TREECODE
            if (vertices[j].level < 32)
            {
                UInt32  b = treeCode[i];

                // shift so child bit for first level is at position 0
                b >>= vertices[j].level;    
                
                // while we're still inside the boundary, move down the
                // tree, using the treeCode as a guide.

                while (vertices[j].level < 32 && flags[j].IsSet(MRV_Inside))
                {
                    Assert(!flags[j].IsSet(MRV_Active), 
                           "vertex is both inside _and_ active");
                    
                    j = vertices[j].child[b & 1];   // move down.
                    b >>= 1;                        // find next child bit
                }

                if (flags[j].IsSet(MRV_Active))
                {
                    v[i] = j;
                    continue;
                }
            }
#endif
            // if can't use treeCode to get down to the active vertex, punt
            // to the leaves and move up.
            j = leafIndexes[i];
        }
                            
        // move up the tree until we hit active vertex
        while (!flags[j].IsSet(MRV_Active))
        {
            Assert(!vertices[j].IsRoot(), "no active vertex before top of vertex tree");
            j = vertices[j].parent;
        }

        faceIndexes[i] = j;
    }
}

---