AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

SFVec3fCellConstrained.cpp

Go to the documentation of this file.

#include "SFVec3fCellConstrained.h"
#include "assertions.h"
#include "ConstrainedVertex.h"



namespace animal
{
namespace octree
{

 Vec3d getNewParametersInCell( Vec3d vParams, Vec3d originalParams, unsigned int diffDepth )
 {
    FloatingPointType scale = 1.0;
    if( diffDepth != 0 )
    {
        scale /= 2<<(diffDepth-1);
    }
    return vParams + originalParams*scale;
 }
 
Vec3d getParametersInFrame( Vec3d params, unsigned short vId )
{
    return Vec3d( LINEARFACTORALPHA(vId,params[0]), LINEARFACTORBETA(vId,params[1]), LINEARFACTORGAMMA(vId,params[2]) );
}








SFVec3fCellConstrained::SFVec3fCellConstrained( X3DTK::SFVec3f *q, Cell* cell, int vertexID, X3DTK::SFVec3f normal ) :
    _vec(q), _cell(cell), _vertexID(vertexID)
{
    computeParameters();
    
    _normal = Vec3d( normal[0], normal[1], normal[2] );
    
    _alphaNormal = _alpha + normal[0] / 100.0;
    _betaNormal = _beta + normal[1] / 100.0;
    _gammaNormal = _gamma + normal[2] / 100.0;
    
    for( unsigned short i=0 ; i<8 ; ++i )
    {
        // Set the parameters in each of our depending vertex, the 8 vertices of the cell
        Vec3d w = getParameters(i);
        setRelativeWeight( _cell->vertex(i), computeWeight( w, LINEAR ) );
        setRelativePosition( _cell->vertex(i), w );
    }
}

SFVec3fCellConstrained::SFVec3fCellConstrained( X3DTK::SFVec3f *q, Cell* cell, Vec3d params, int vertexID, Vec3d normal ) :
    _vec(q), _cell(cell), _normal(normal), _vertexID(vertexID)
{
    _alpha = params[0];
    _beta = params[1];
    _gamma = params[2];
    
    _alphaNormal = _alpha + normal[0] / 100.0;
    _betaNormal = _beta + normal[1] / 100.0;
    _gammaNormal = _gamma + normal[2] / 100.0;  
}
    
SFVec3fCellConstrained::~SFVec3fCellConstrained( )
{
}

void SFVec3fCellConstrained::setParams( const Vec3d params )
{
    _alpha = params[0];
    _beta= params[1];
    _gamma = params[2];
}

FloatingPointType SFVec3fCellConstrained::computeWeight( Vec3d w, int method )
{
    switch( method )
    {
        case LINEAR:
            return (1.0-w[0]) * (1.0-w[1]) * (1.0-w[2]);
        case LOCAL_SKINNING:
            return hf.compute(w[0]) * hf.compute(w[1]) * hf.compute(w[2]);
        default:
            std::cerr << "SFVec3fCellConstrained::computeWeight() : Unknown method\n";
            return 0.0;
    }
}


void SFVec3fCellConstrained::updatePosition( int method )
{
    Vec3d v = computePosition(method);
                        
    _vec->x = v[0];
    _vec->y = v[1];
    _vec->z = v[2];
}



void SFVec3fCellConstrained::computeParameters()
{
    
    Vec3d q(_vec->x,_vec->y,_vec->z);
    Vec3d v = q - _cell->vertex(0)->getPosition();

    Vec3d va = _cell->vertex(1)->getPosition() - _cell->vertex(0)->getPosition();
    Vec3d vb = _cell->vertex(2)->getPosition() - _cell->vertex(0)->getPosition();
    Vec3d vc = _cell->vertex(4)->getPosition() - _cell->vertex(0)->getPosition();
    
    _alpha = (v*va) / (va.norm()*va.norm());
    _beta  = (v*vb) / (vb.norm()*vb.norm());
    _gamma = (v*vc) / (vc.norm()*vc.norm());
}   
    
    
    
    
    
    /*
        std::deque<unsigned int> SFVec3fCellConstrained::getAlphaFactors( Cell *cell, unsigned int faceId, unsigned int depthLeft )
    {
        //std::cerr << "Faceid is " << faceId << " and fatherpos is " << cell->fatherPos() << "\n";
        Require( !cell->isRoot() );
        
        if( depthLeft == 0 )
        {
            return std::deque<unsigned int>(0);
        }
        else
        {
            std::deque<unsigned int> parents = getAlphaFactors( cell->father(), faceId, depthLeft-1 );
            
            unsigned int myId = cell->fatherPos();
            if( (myId%2) == 0 )
                // This is a bottom cell, return 0
                parents.push_back(0);
            else
                parents.push_back(1);
                
            return parents;
        }
    }
    
    std::deque<unsigned int> SFVec3fCellConstrained::getBetaFactors( Cell *cell, unsigned int faceId, unsigned int depthLeft )
    {
        //std::cerr << "Faceid is " << faceId << " and fatherpos is " << cell->fatherPos() << "\n";
        Require( !cell->isRoot() );
        
        if( depthLeft == 0 )
        {
            return std::deque<unsigned int>(0);
        }
        else
        {
            std::deque<unsigned int> parents = getBetaFactors( cell->father(), faceId, depthLeft-1 );
            
            unsigned int myId = cell->fatherPos();
            if( (myId%4) <= 1 )
                // This is a bottom cell, return 0
                parents.push_back(0);
            else
                parents.push_back(1);
                
            return parents;
        }
    }

    std::deque<unsigned int> SFVec3fCellConstrained::getGammaFactors( Cell *cell, unsigned int faceId, unsigned int depthLeft )
    {
        if( depthLeft == 0 )
        {
            return std::deque<unsigned int>(0);
        }
        else
        {
            std::deque<unsigned int> parents = getGammaFactors( cell->father(), faceId, depthLeft-1 );
            
            unsigned int myId = cell->fatherPos();
            if( myId <= 3 )
                // This is a bottom cell, return 0
                parents.push_back(0);
            else
                parents.push_back(1);
                
            return parents;
        }
    }

    
    
    
    
    
TempOctree::Vertex*  SFVec3fCellConstrained::getSmallestCellsFreeVertexSharingFaceForVertex( Cell *neighbour, unsigned int face, unsigned int vertex )
{
    Require( !neighbour->isLeaf() );
    
    unsigned int direction;
    if( face <= 1 )
        direction = 0; //x
    else if( face >= 4 )
        direction = 2; //z
    else
        direction = 1; //y
    
    unsigned int childPos = Cell::connectedVertices[vertex][direction];
//  unsigned int vId = childPos;
    
    Cell *prec = NULL;
    Cell* res = neighbour;
    while( !res->isLeaf() && res->vertex(vertex)->isFree() )
    {
        prec = res;
        res = res->child(childPos);
    }
    
    if( !res->vertex(vertex)->isFree() )
    {
        Require( prec != NULL );
        return prec->vertex(vertex);
    }
    else
        return res->vertex(vertex);
}
*/
    
    
    
    
        /*
     * Compute a point position giving the cell and alpha beta and gamma and method
     */
Vec3d SFVec3fCellConstrained::computePosition( int method ) const
{
        Vec3d vRes;


                        
        switch( method )
        {
            case LINEAR :
            {
            vRes =
                (1.0-_gamma)*(
                    (1.0-_beta)*( (1-_alpha)*_cell->vertex(0)->getPosition() + _alpha*_cell->vertex(1)->getPosition() )
                    +
                    _beta      *( (1-_alpha)*_cell->vertex(2)->getPosition() + _alpha*_cell->vertex(3)->getPosition() ) )
                +
                _gamma*(
                    (1.0-_beta)*( (1-_alpha)*_cell->vertex(4)->getPosition() + _alpha*_cell->vertex(5)->getPosition() )
                    +
                    _beta      *( (1-_alpha)*_cell->vertex(6)->getPosition() + _alpha*_cell->vertex(7)->getPosition() )
                );
                
                return vRes;
            }

            case LOCAL_SKINNING:
            {

                CellInfluenceData & cid = _cell->getData()._influence;

                FloatingPointType wSum = 0.0;
                FloatingPointType w;
                for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
                {
//                  w = getRelativeWeight( cid.vertices[i] ) / (pow(4.0,cid.vertices[i]->getDepth()));
                    w = getRelativeWeight( cid.vertices[i] );
                    Frame &f = cid.vertices[i]->getFrame();
                    Vec3d relPos = getRelativePosition(cid.vertices[i]);
//                  Vec3d initSize(0.5,0.5,0.5);
                    Vec3d initSize(1.0,1.0,1.0);
//                      Vec3d initSize = ((Cell*)cid.parents[i])->getData()._initialSize;
//                  Frame f2( f.getOrigin(), (f[0]/f[0].norm()), (f[1]/f[1].norm()), (f[2]/f[2].norm()) );

                    
//                  vRes += w * f2.computePosition( relPos, initSize );
                    vRes += w * f.computePosition( relPos, initSize );
//                  vRes += w * cid.vertices[i]->getFrame().computePosition( getRelativePosition(cid.vertices[i]), ((Cell*)cid.parents[i])->getData()._initialSize );
                    wSum += w;
                }

                vRes /= wSum;

                return vRes;
            }
            
            default:
            {
                std::cerr << "SFVec3fCellConstrained::computePosition() : unknown method\n";
                return Vec3d(0.0,0.0,0.0);
            }
    }
}


std::vector<Vec3d> SFVec3fCellConstrained::computeDerivative( ) const
{
    std::vector<Vec3d> res(3);
    
    static const FloatingPointType d = 10e-5;
    
     SFVec3fCellConstrained tmpVec = *this;
     Vec3d posT, posB;

         
     tmpVec.setParams( this->getLocalParams() + Vec3d(d,0.0,0.0) );
     tmpVec.updateSkinningInformations( _cell->getData()._influence );
     posT = tmpVec.computePosition( LOCAL_SKINNING );
     tmpVec.setParams( this->getLocalParams() + Vec3d(-d,0.0,0.0) );
     tmpVec.updateSkinningInformations( _cell->getData()._influence );
     posB = tmpVec.computePosition( LOCAL_SKINNING );
     res[0] = (posT-posB)/(2.0*d);

     tmpVec.setParams( this->getLocalParams() + Vec3d(0.0,+d,0.0) );
     tmpVec.updateSkinningInformations( _cell->getData()._influence );
     posT = tmpVec.computePosition( LOCAL_SKINNING );
     tmpVec.setParams( this->getLocalParams() + Vec3d(0.0,-d,0.0) );
     tmpVec.updateSkinningInformations( _cell->getData()._influence );
     posB = tmpVec.computePosition( LOCAL_SKINNING );
     res[1] = (posT-posB)/(2.0*d);

     tmpVec.setParams( this->getLocalParams() + Vec3d(0.0,0.0,+d) );
     tmpVec.updateSkinningInformations( _cell->getData()._influence );
     posT = tmpVec.computePosition( LOCAL_SKINNING );
     tmpVec.setParams( this->getLocalParams() + Vec3d(0.0,0.0,-d) );
     tmpVec.updateSkinningInformations( _cell->getData()._influence );
     posB = tmpVec.computePosition( LOCAL_SKINNING );
     res[2] = (posT-posB)/(2.0*d);
    
     return res;
//  std::vector<Vec3d> res(3);
//  
//  CellInfluenceData & cid = _cell->getData()._influence;
// 
//  FloatingPointType w;
// 
//  FloatingPointType kiSum = 0.0;  // sum_i k_i
//  Vec3d kiDerSum;         // sum_i \frac{ \partial k_i }{ \partial \alpha }
//  
//  std::vector<FloatingPointType> ki(cid.vertices.size()); // k_i 
//  std::vector<Vec3d> kiDer(cid.vertices.size());  // \frac{ \partial k_i }{ \partial x_j }
//  
//  FloatingPointType sign = 0.0;
//  for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
//  {
//      Vec3d relPos = getRelativePosition(cid.vertices[i]);
//      
//      kiSum += getRelativeWeight( cid.vertices[i] );
//      
//      Vec3d paramSum;
//      for( unsigned int v=0 ; v<8 ; ++v )
//      {
//          FloatingPointType w = computeWeight( getParameters(v), LINEAR );
//          paramSum += w * cid.influenceMaps[i][_cell->vertex(v)]; 
//      }
//      ki[i] = computeWeight( paramSum, LOCAL_SKINNING );
//      // Should be the same as getRelativeWeight( cid.vertices[i] )
// 
//      std::vector<Vec3d> wjDers(8);
//      Vec3d wjDerSum;
//      for( unsigned int v=0 ; v<8 ; ++v )
//      {
//          Vec3d signs;
//          if( (v%2) == 0 ) { signs[0] = +1.0;} else { signs[0] = -1.0; }
//          if( (v%4) <= 1 ) { signs[1] = +1.0;} else { signs[1] = -1.0; }
//          if( v < 4 ) { signs[2] = +1.0;} else { signs[2] = -1.0; }
//          
//          Vec3d paramsj = getParameters(v);
//          Vec3d wjDer;
//          wjDers[v][0] = - signs[0] * (1.0-paramsj[1]) * (1.0-paramsj[2]);
//          wjDers[v][1] = - signs[1] * (1.0-paramsj[0]) * (1.0-paramsj[2]);
//          wjDers[v][2] = - signs[2] * (1.0-paramsj[0]) * (1.0-paramsj[1]);
//          
//          wjDerSum += wjDers[v];
//          
//          Vec3d infj = cid.influenceMaps[i][_cell->vertex(v)];
//          
//          kiDer[i] += wjDers[v]*infj[0] * hf.computeDerivative( paramSum[0] ) * hf.compute( paramSum[1] ) * hf.compute( paramSum[2] );
//          kiDer[i] += wjDers[v]*infj[1] * hf.compute( paramSum[0] ) * hf.computeDerivative( paramSum[1] ) * hf.compute( paramSum[2] );
//          kiDer[i] += wjDers[v]*infj[2] * hf.compute( paramSum[0] ) * hf.compute( paramSum[1] ) * hf.computeDerivative( paramSum[2] );
//      }
//      
//      kiDerSum += kiDer[i];
//  }
//  
//  for( unsigned int i=0 ; i<cid.vertices.size() ; ++i )
//  {
//      Frame &f = cid.vertices[i]->getFrame();
//      Vec3d relPos = getRelativePosition(cid.vertices[i]);
//      
//      Vec3d myPos = f.computePosition( relPos, Vec3d(1,1,1) );
//      
//      w = getRelativeWeight( cid.vertices[i] ) / kiSum;
//      
//      FloatingPointType wDer;
//      
//      // on alpha
//      // First : (+/-) ki * Ui
//      if( (cid.verticesId[i]%2) == 0 ) { sign = +1.0;} else { sign = -1.0; }
//      res[0] += w * f.getVector( 0 );
//      // Second : (+/-) f'(alpha) f(beta) Qi
//      wDer = (kiDer[i][0] * kiSum - ki[i] * kiDerSum[0]) / (kiSum*kiSum);
// //       wDer = hf.computeDerivative( relPos[0] ) * hf.compute( relPos[1] ) * hf.compute( relPos[2] ) * wSum;
// //       wDer -= w * wDerSum[0];
// //       wDer /= wSum*wSum;
//      
//      res[0] += wDer * myPos;
//      
//      // on beta now
//      if( (cid.verticesId[i]%4) <= 1 ) { sign = +1.0;} else { sign = -1.0; }
//      res[1] += w * f.getVector( 1 );
//      wDer = (kiDer[i][1] * kiSum - ki[i] * kiDerSum[1]) / (kiSum*kiSum);
// //       wDer = hf.compute( relPos[0] ) * hf.computeDerivative( relPos[1] ) * hf.compute( relPos[2] ) * kiSum;
// //       wDer -= w * kiDerSum[1];
// //       wDer /= kiSum*kiSum;
//      
//      res[1] += wDer * myPos;
//      
//      // on gamma now
//      if( cid.verticesId[i] < 4 ) { sign = +1.0;} else { sign = -1.0; }
//      res[2] += w * f.getVector( 2 );
//      wDer = (kiDer[i][2] * kiSum - ki[i] * kiDerSum[2]) / (kiSum*kiSum);
// //       wDer = hf.compute( relPos[0] ) * hf.compute( relPos[1] ) * hf.computeDerivative( relPos[2] ) * kiSum;
// //       wDer -= w * kiDerSum[2];
// //       wDer /= kiSum*kiSum;
//      res[2] += wDer * myPos;
//      
//  }
//  
//  return res;
    
}
    

    Vec3d SFVec3fCellConstrained::getParameters( unsigned short vId ) const
    {
        Require( vId < 8 );
        return Vec3d(LINEARFACTORALPHA(vId,_alpha),LINEARFACTORBETA(vId,_beta),LINEARFACTORGAMMA(vId,_gamma));
    }
    
    
    void SFVec3fCellConstrained::updateSkinningInformations( CellInfluenceData & influence )
    {
        this->clearRelativePositions(  );
        this->clearRelativeWeights(  );
        
        // For every depending vertex given by "influence"
        // find the local coordinates in each frame and find the associated weight
        for( unsigned short vId=0 ; vId < influence.vertices.size() ; ++vId )
        {
            /*
            X3DTK::SFVec3f * QSF = getSFVec3f();
            Vec3d Q( QSF->x, QSF->y, QSF->z );
            
            Frame f = influence.vertices[vId]->getFrame();
            this->setRelativePosition( influence.vertices[vId], f.getLocalCoordinates( Q ) );
            */
            Vec3d params = translateParameters( this->getCell(), this->getLocalParams(), (Cell*)influence.parents[vId], influence.verticesId[vId] );
            this->setRelativePosition( influence.vertices[vId], params );
            
            Vec3d paramW;
            for( unsigned short i=0 ; i<8 ; ++i )
            {
                FloatingPointType w = computeWeight( getParameters(i), LINEAR );
                paramW += w * influence.influenceMaps[vId][_cell->vertex(i)];
            }           
            FloatingPointType w = computeWeight( paramW, LOCAL_SKINNING );
            this->setRelativeWeight( influence.vertices[vId], w );
        }       
    }

    
    
    
    
    
void SFVec3fCellConstrained::globalLinearUpdatePositions( Cell *cStart )
{
    for( Cell::vertex_width_iterator it(cStart) ; !it.empty() ; )
    {
        ConstrainedVertex* v = ++it;
        
        if( v->isFree() )
        {
            Vec3d delta = v->getDelta();
            X3DTK::SFVec3f sfDelta(delta[0],delta[1],delta[2]);

            for( unsigned int i=0 ; i<v->nConnectedCells() ; ++i )
            {
                Cell *cell = v->connectedCell(i);

                if( cell->getData()._depth == v->getDepth() )
                {
                    unsigned int vId;
                    for( vId=0 ; vId<8 ; ++vId )
                    {
                        if( cell->vertex(vId) == v )
                        {
                            break;
                        }
                    }

                    OctreeDataPoints *points = &(cell->getData()._points);
                    for( OctreeDataPoints::iterator it = points->begin() ; it != points->end() ; ++it )
                    {
                        X3DTK::SFVec3f *vec = (*it)->getSFVec3f();
                        FloatingPointType weight = hf.compute(LINEARFACTORALPHA(vId,(*it)->getAlpha())) * hf.compute(LINEARFACTORBETA(vId,(*it)->getBeta())) * hf.compute(LINEARFACTORGAMMA(vId,(*it)->getGamma()));
                        weight /= ((FloatingPointType) v->getDepth() + 1.0);
                        *vec += weight*sfDelta;
                    }
                }
            }
        }

        v->setDelta( Vec3d(0,0,0) );
    }
}

Vec3d SFVec3fCellConstrained::getInitNormalParameters( unsigned short vId ) const
{
    Require( vId < 8 );
    return Vec3d(LINEARFACTORALPHA(vId,_alphaNormal),LINEARFACTORBETA(vId,_betaNormal),LINEARFACTORGAMMA(vId,_gammaNormal));
}


Vec3d SFVec3fCellConstrained::translateParameters( Cell *cStart, Vec3d params, Cell *cDest, unsigned short vId )
{
    //std::cerr << "SFVec3fCellConstrained::translateParameters" << *cStart << "\n";
    
    Vec3d result = params;
    
    Cell *cell = cStart;
    
    while( cell != cDest )
    {
        if( (cell->fatherPos()%2) == 0 )
        {
            result[0] /= 2.0;
        }
        else
        {
            result[0] = (result[0]+1.0)/2.0;
        }
        if( (cell->fatherPos()%4) <= 1 )
        {
            result[1] /= 2.0;
        }
        else
        {
            result[1] = (result[1]+1.0)/2.0;
        }
        if( cell->fatherPos() <= 3 )
        {
            result[2] /= 2.0;
        }
        else
        {
            result[2] = (result[2]+1.0)/2.0;
        }   
        //std::cerr << "\t" << *cell << " : params were " << params << " and now : " << result << "\n";     
        cell = cell->father();
    }
    
    // Now translate this in the vID vertex' frame
    result = Vec3d( LINEARFACTORALPHA(vId,result[0]), LINEARFACTORBETA(vId,result[1]), LINEARFACTORGAMMA(vId,result[2]) );
    if( (vId%2) == 1 )
    {
        result[0] *= -1;
    }
    if( (vId%4) >= 2 )
    {
        result[1] *= -1;
    }
    if( vId >= 4 )
    {
        result[2] *= -1;
    }
    
    return result;
}


}
}

---