source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/leaves/Leaf.cpp @ 1526

#include <math.h>
#include "Leaf.h"

//--------------------------------------------------------------------------------------------------------------------------------
// Void constructor
// Parameters --> None
//--------------------------------------------------------------------------------------------------------------------------------
Leaf::Leaf(void) 
{       
        vertsLeaf[0] = vertsLeaf[1] = vertsLeaf[2] = vertsLeaf[3] =0; 
        center[0] = center[1] = center[2] = 0;
//      normal[0] = normal[1] = normal[2] = 0;
        leafNear=-1;
        parentLeafCount = 1;
        dist = -1;
        coplanar = -1;
        criteria = -1;
        leafCop = -1;
        leafCrit =-1;
        exists = false;
        parent=-1;
        childLeft = childRight = -1;
        root = visible= -1;
}


//--------------------------------------------------------------------------------------------------------------------------------
// Copy constructor
//--------------------------------------------------------------------------------------------------------------------------------
Leaf::Leaf (const Leaf& aLeaf)
{
        parentLeafCount = aLeaf.parentLeafCount;;
        leafNear = aLeaf.leafNear;
        leafCrit = aLeaf.leafCrit;
        dist = aLeaf.dist;
        exists = aLeaf.exists;
        coplanar = aLeaf.coplanar;
        leafCop = aLeaf.leafCop;
        criteria = aLeaf.criteria;
        for ( int i=0;i<3;i++){
                center[i] = aLeaf.center[i];
//              normal[i] = aLeaf.normal[i];
        }
        for (i = 0L; i < 4; i++)
                vertsLeaf[i] = aLeaf.vertsLeaf[i]; 
        
        parent = aLeaf.parent;
        childLeft = aLeaf.childLeft;
        childRight = aLeaf.childRight;
        visible = aLeaf.visible;
        root = aLeaf.root;
}


RuntimeLeaf::RuntimeLeaf(void) 
{       
        vertsLeaf[0] = vertsLeaf[1] = vertsLeaf[2] = vertsLeaf[3] = 0;
        parent = root = childLeft = childRight = -1;
}

//--------------------------------------------------------------------------------------------------------------------------------
// Copy constructor
//--------------------------------------------------------------------------------------------------------------------------------
RuntimeLeaf::RuntimeLeaf (const RuntimeLeaf& aLeaf)
{
        for (int i = 0L; i < 4; i++)
                vertsLeaf[i] = aLeaf.vertsLeaf[i]; 
        parent = aLeaf.parent;
        childLeft = aLeaf.childLeft;
        childRight = aLeaf.childRight;
        root = aLeaf.root;
}


//--------------------------------------------------------------------------------------------------------------------------------
//  CALCULA LA DISTANCIA ENTRE HOJAS
//--------------------------------------------------------------------------------------------------------------------------------

float Leaf::Distance (Leaf& leaf)
{
        float dist =0;
        float x1,y1,z1;

        x1 = leaf.center[0]; y1 = leaf.center[1] ; z1 = leaf.center[2];


        //DISTANCIA BETWEEN CENTERS

        dist = ((center[0]-x1)*(center[0]-x1)) + ((center[1]-y1)*(center[1]-y1)) + ((center[2]-z1)*(center[2]-z1));

        return dist;
}


//--------------------------------------------------------------------------------------------------------------------------------
//  CALCULA LA COPLANARIDAD ENTRE HOJAS
//--------------------------------------------------------------------------------------------------------------------------------

float Leaf::Coplanarity (Leaf& leaf)
{
        float cop =0;
        float modulo1, modulo2;
        float x1,y1,z1, nx1, ny1, nz1;
        float nx, ny, nz;

        //hoja pasada como parametro, normalizo las componentes
        x1 = leaf.normal[0]; y1 = leaf.normal[1] ; z1 = leaf.normal[2];
        modulo1 = sqrt ( (x1*x1) + (y1*y1) + (z1*z1));
        nx1 = x1 / modulo1;
        ny1 = y1 / modulo1;
        nz1 = z1 / modulo1;

        // hoja desde la que llamo

        modulo2 = sqrt ( (normal[0]*normal[0]) + (normal[1]*normal[1]) + (normal[2]*normal[2]));
        nx = normal[0] / modulo2;
        ny = normal[1] / modulo2;
        nz = normal[2] / modulo2;

        // producto escalar : si es proximo a 0, perpendiculares, a 1, coplanares

        cop = (nx1*nx) + (ny1*ny) + (nz1*nz);


        return (fabs(cop));

}