AnimaL

Tutorial

Documentation

---

Documentation

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

---

ConstrainedVertex.h

Go to the documentation of this file.

/***************************************************************************
                          constrainedvertex.h  -  description
                             -------------------
    begin                : Wed Jan 14 2004
    copyright            : (C) 2004 by Mathieu Coquerelle
    email                : mathieu.coquerelle@imag.fr
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef CONSTRAINEDVERTEX_H
#define CONSTRAINEDVERTEX_H

#include <animal/array.h>
#include <vector>
using std::vector;
#include <deque>
using std::deque;
#include <set>

namespace animal
{
namespace octree
{

class ConstrainedVertex;
typedef ConstrainedVertex CVertex; // Shortcut

}
}




#include "fastoctreedeformableconstrained.h"
//#include "vec3d.h"
#include "octree_instanciation.h"
#include "GeoLink.h"
#include "Frame.h"


namespace animal
{
namespace octree
{






class ConstrainedVertex
{
public:

    //class VVec3d;


    ConstrainedVertex(  Vec3d v, CVertex *cv1, CVertex *cv2, CVertex *cv3, CVertex *cv4,
                       CVertex *cv5, CVertex *cv6, CVertex *cv7, CVertex *cv8,
                       Cell *connectedCell );

    ConstrainedVertex( Vec3d position,  Cell *connectedCell );
    ConstrainedVertex( FloatingPointType x, FloatingPointType y, FloatingPointType z,  Cell *connectedCell );

    //Copy constructor
    // Only copies the position
    ConstrainedVertex( const ConstrainedVertex & cmsv );

    ConstrainedVertex & operator=( const ConstrainedVertex & cmsv );

    ~ConstrainedVertex();


    bool isFree() const;



    Vec3d get_Vec3d() const;
    operator const Vec3d() const;
    Vec3d getPosition() const;
    void addPosition( Vec3d addPos );


    /* Return a pointer to the positions
     * This is for a read only use !
     * mainly used with opengl : glVertex3fv( CV );
     */
    operator const FloatingPointType*();
    FloatingPointType operator []( int ) const;

    FloatingPointType* get_FloatingPointTypePointerCopy() const;











    void updatePosition( ConstrainedVertex* parent, Vec3d v );
    void updateChildrensPosition( Vec3d v, unsigned int depth );
    void updateChildrensPositionOptimized( Vec3d v, unsigned int depth );
    void updateChildrensPositionOptimizedNotFree( Vec3d v );

    // Called on constrained children so that they modify themselves and their children
    void updateConstrainedChildrensPosition( Vec3d v, unsigned int depth );

    GeoLink* getGeoLink() const;


    void freeIt();


    Vec3d getParameters( Cell *cStart, unsigned short vId );
    Vec3d getParameters( Cell *cStart, unsigned int depth, unsigned short vId );
    ConstrainedVertex* getFathersFreeVertex( Cell *cStart, unsigned short vId );
    Cell* getFathersFreeVertexCell( Cell *cStart, unsigned short vId );



    /*
     * Only a geo link for MR edition
     */
    void softLinkIt( ConstrainedVertex* cv1, ConstrainedVertex* cv2 );
    void softLinkIt( ConstrainedVertex* cv1, ConstrainedVertex* cv2, ConstrainedVertex* cv3, ConstrainedVertex* cv4 );
    void softLinkIt( ConstrainedVertex* cv1, ConstrainedVertex* cv2, ConstrainedVertex* cv3, ConstrainedVertex* cv4, ConstrainedVertex* cv5, ConstrainedVertex* cv6, ConstrainedVertex* cv7, ConstrainedVertex* cv8 );


    void hardLinkIt( ConstrainedVertex* cv1, ConstrainedVertex* cv2, ConstrainedVertex* cv3, ConstrainedVertex* cv4 );
    void hardLinkIt( ConstrainedVertex* cv1, ConstrainedVertex* cv2 );



    bool isChild( const ConstrainedVertex *cv ) const;

    void addChild( ConstrainedVertex *cv );
    void removeChild( ConstrainedVertex *cv );

    unsigned int getChildPos( ConstrainedVertex *cv ) const;

    ConstrainedVertex * child( const unsigned int pos ) const;

    unsigned int nChildren() const;
    bool isParent( const ConstrainedVertex *cv ) const;



    /*
     * Cells which are connected to this vertex
    * This is perhaps NOT updated when linkIt and freeIt is used !
    */

    void unregisterCell( const Cell* unconnectedCell );
    void registerCell( Cell *connectedCell );
    unsigned short nConnectedCells() const;
    bool isConnected( const Cell* cell ) const;
    Cell* connectedCell( unsigned short id ) const;

    /*
     * Return our father cell which is the cell which have created us
     */
    Cell* fatherCell() const;

    /*
    * Get the depth of the vertex based on our father's depth
    */
    unsigned int getDepth() const;


    void setData( const ConstrainedVertexData& d );
    ConstrainedVertexData getData( ) const;


    void updateFrame();
    Frame computeFrame();
    Frame & getFrame();


    bool hasMainCell( ) const;
    void setMainCell( Cell* mainCell, unsigned int vId );
    Cell* getMainCell() const;
    unsigned short getMainCellVertexId() const
    {
        return _vertexId;
    }


    static FloatingPointType getAlpha( Cell *cell, unsigned int faceId, unsigned int vId, unsigned int diffDepth );
    static FloatingPointType getBeta( Cell *cell, unsigned int faceId, unsigned int vId, unsigned int diffDepth );
    static FloatingPointType getGamma( Cell *cell, unsigned int faceId, unsigned int vId, unsigned int diffDepth );


    ConstrainedVertex* getSmallestCellsFreeVertexSharingFaceForVertex( Cell *neighbour, unsigned int face, unsigned int vertex );
    Cell*   getCellWithFreeVertexConnectedToVertex( Cell *cell, unsigned int direction, unsigned int vertexId ) const;


    static std::set
        <ConstrainedVertex*> getFreeParentVertices( Cell *cell );
    
    
    FloatingPointType _mass;

protected:

    void copyAllData( const ConstrainedVertex & cmsv );



    Vec3d _position;

    Vec3d _velocity;
    //Vec3d _material_coordinates; // FF How to set them ?


    FloatingPointType _positionROPointer[3];

    std::vector<ConstrainedVertex*> _childs;

    deque<Cell*> _connectedCells;

    Cell* _fatherCell;

    // This vertex ID's in _mainCell
    unsigned short _vertexId;
    // The vertex in which we belong
    Cell* _mainCell;


    ConstrainedVertexData _data;

    GeoLink *_geoLink;

    Frame _frame;


    static std::deque<unsigned int> getAlphaFactors( Cell *cell, unsigned int faceId, unsigned int depthLeft );
    static std::deque<unsigned int> getBetaFactors( Cell *cell, unsigned int faceId, unsigned int depthLeft );
    static std::deque<unsigned int> getGammaFactors( Cell *cell, unsigned int faceId, unsigned int depthLeft );


    // DEBUG PURPOSE
public:

    void setPosition( Vec3d newPos );

    void setPositionAndPropagate( Vec3d newPos );

    void setPositionAndPropagateAll( Vec3d newPos, unsigned int depth );

    Vec3d computePosition() const;



    Vec3d getDelta() const;
    void setDelta( Vec3d d );
    Vec3d computeDelta() const;

    enum { POS=0, VEL, ACC, VELHALF, NB_AUXILIARY_VECTORS };

    Vec3d& value( int value_id );

    const Vec3d& value( int value_id ) const;

    void setValue( int value_id, Vec3d newPos );

    void setValueAndPropagate( int value_id, Vec3d newPos );

//     /** Set the tagged value, and
//      * also modify all our children recursively to keep geometric coherancy
//      * This is for MR edition purpose only !
//      * This is limited to the given depth
//      */
//     void setValueAndPropagateAll(  int value_id, Vec3d newPos, unsigned int depth );

    Vec3d computeValue( int value_id ) const;

    void computeValueFromParents( int value_id );

    void computeValueFromRelatives( int value_id );


    //  void addDelta( Vec3d d );
    //  void clearDelta();
    //  Vec3d getDelta() const;


    //  void set( FloatingPointType x, FloatingPointType y, FloatingPointType z, unsigned int depth );
    //  void set( Vec3d newPos, unsigned int depth );




    //  void moveIndependent( FloatingPointType x, FloatingPointType y, FloatingPointType z );
    //  void moveIndependent( Vec3d newPos );
    
protected:
    animal::Array<NB_AUXILIARY_VECTORS,Vec3d> _aux;
    Vec3d _delta;
    
public:
    ConstrainedVertex *_connectedVertices[3][2];
    FloatingPointType _connectedVerticesFactors[3][2];

    
    unsigned int getConstrainedDepth() const;
    unsigned int _lastConstrainedDepth;
};




class Cell::vertex_connected_iterator
{
public:

    vertex_connected_iterator( ConstrainedVertex* vertex, Cell *cell, unsigned int vPos );
    ~vertex_connected_iterator();

    TempOctree::Vertex* operator++();
    bool empty();

private:
    std::list<TempOctree::Vertex*> _vList;
};

static std::ostream& operator<<(std::ostream& s, const ConstrainedVertex& v)
{
    s << *(v.getMainCell()) << " : " << v.getMainCellVertexId();
    return s;
}


}
}

#endif

---