MeshTopology.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                               SOFA :: Modules                               *
*                                                                             *
* Authors: The SOFA Team and external contributors (see Authors.txt)          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_COMPONENT_TOPOLOGY_MESHTOPOLOGY_H
#define SOFA_COMPONENT_TOPOLOGY_MESHTOPOLOGY_H

#include <stdlib.h>
#include <vector>
#include <string>
#include <iostream>
#include <sofa/core/componentmodel/topology/Topology.h>
#include <sofa/core/componentmodel/topology/BaseMeshTopology.h>
#include <sofa/helper/fixed_array.h>
#include <sofa/helper/vector.h>

namespace sofa
{

namespace component
{

class MeshLoader;

namespace topology
{

using namespace sofa::defaulttype;
using helper::vector;
using helper::fixed_array;


class MeshTopology : public core::componentmodel::topology::BaseMeshTopology
{
  public:

    MeshTopology();
        
    virtual void init();
    
    virtual int getNbPoints() const;

    virtual void setNbPoints(int n);
    
    // Complete sequence accessors
    
    virtual const SeqEdges& getEdges();
    virtual const SeqTriangles& getTriangles();
    virtual const SeqQuads& getQuads();
    virtual const SeqTetras& getTetras();
    virtual const SeqHexas& getHexas();
    
    // Random accessors
    
    virtual int getNbEdges();
    virtual int getNbTriangles();
    virtual int getNbQuads();
    virtual int getNbTetras();
    virtual int getNbHexas();
    
    virtual Edge getEdge(EdgeID i);
    virtual Triangle getTriangle(TriangleID i);
    virtual Quad getQuad(QuadID i);
    virtual Tetra getTetra(TetraID i);
    virtual Hexa getHexa(HexaID i);

    virtual const VertexEdges &getEdgeVertexShell(PointID i);
    virtual const TriangleEdges &getEdgeTriangleShell(TriangleID i);
    virtual const QuadEdges &getEdgeQuadShell(QuadID i);
    virtual const TetraEdges& getEdgeTetraShell(TetraID i);
    virtual const HexaEdges& getEdgeHexaShell(HexaID i);
    virtual const VertexTriangles &getTriangleVertexShell(PointID i);
    virtual const EdgeTriangles &getTriangleEdgeShell(EdgeID i);
    virtual const TetraTriangles& getTriangleTetraShell(TetraID i);
    virtual const VertexQuads &getQuadVertexShell(PointID i);
    virtual const EdgeQuads &getQuadEdgeShell(EdgeID i);
    virtual const HexaQuads& getQuadHexaShell(HexaID i);
    virtual const VertexTetras& getTetraVertexShell(PointID i);
    virtual const EdgeTetras& getTetraEdgeShell(EdgeID i);
    virtual const TriangleTetras& getTetraTriangleShell(TriangleID i);
    virtual const VertexHexas& getHexaVertexShell(PointID i);
    virtual const EdgeHexas& getHexaEdgeShell(EdgeID i);
    virtual const QuadHexas& getHexaQuadShell(QuadID i);
        
    // Points accessors (not always available)

    virtual bool hasPos() const;
    virtual double getPX(int i) const;
    virtual double getPY(int i) const;
    virtual double getPZ(int i) const;

    // for procedural creation without file loader
    virtual void clear();
    void addPoint(double px, double py, double pz);
    void addEdge( int a, int b );
    void addTriangle( int a, int b, int c );
    void addQuad( int a, int b, int c, int d );
    void addTetra( int a, int b, int c, int d );
    void addHexa( int a, int b, int c, int d, int e, int f, int g, int h );

    int getRevision() const { return revision; }
    
    virtual bool isCubeActive(int /*index*/) { return true; }    

    void draw();

protected:
    int nbPoints;
    vector< fixed_array<SReal,3> > seqPoints;
    
    Data<SeqEdges> seqEdges;
    bool validEdges;
    
    //SeqTriangles   seqTriangles;
        Data<SeqTriangles> seqTriangles;
    bool         validTriangles;
    
    //SeqQuads       seqQuads;
    Data<SeqQuads>       seqQuads;
    bool         validQuads;
    
    //SeqTetras      seqTetras;
    Data<SeqTetras>      seqTetras;
    bool         validTetras;
    
#ifdef SOFA_NEW_HEXA
    //SeqHexas     seqHexas;
    Data<SeqHexas>     seqHexas;
#else
    Data<SeqCubes>       seqHexas;
#endif
    bool         validHexas;
    

    vector< VertexEdges > m_edgeVertexShell;

    vector< TriangleEdges > m_edgeTriangleShell;

    vector< QuadEdges > m_edgeQuadShell;

    vector< TetraEdges > m_edgeTetraShell;

    vector< HexaEdges > m_edgeHexaShell;

    vector< VertexTriangles > m_triangleVertexShell;

    vector< EdgeTriangles > m_triangleEdgeShell;
    
    vector< TetraTriangles > m_triangleTetraShell;

    vector< VertexQuads > m_quadVertexShell;
    
    vector< EdgeQuads > m_quadEdgeShell;
    
    vector< HexaQuads > m_quadHexaShell;
    
    vector< VertexTetras> m_tetraVertexShell;

    vector< EdgeTetras > m_tetraEdgeShell;
    
    vector< TriangleTetras > m_tetraTriangleShell;

    vector< VertexHexas > m_hexaVertexShell;
    
    vector< EdgeHexas > m_hexaEdgeShell;
    
    vector< QuadHexas > m_hexaQuadShell;
        
    void createEdgeVertexShellArray();

    void createEdgeTriangleShellArray();

    void createEdgeQuadShellArray();

    void createEdgeTetraShellArray();

    void createEdgeHexaShellArray();

    void createTriangleVertexShellArray();

    void createTriangleEdgeShellArray();

    void createTriangleTetraShellArray ();

    void createQuadVertexShellArray ();

    void createQuadEdgeShellArray();

    void createQuadHexaShellArray ();

    void createTetraVertexShellArray ();

    void createTetraEdgeShellArray();

    void createTetraTriangleShellArray();

    void createHexaVertexShellArray();

    void createHexaEdgeShellArray ();

    void createHexaQuadShellArray();



    const vector< VertexTriangles > &getTriangleVertexShellArray() ;

    const vector< VertexQuads >& getQuadVertexShellArray();



    int getEdgeIndex(PointID v1, PointID v2);
    
    int getTriangleIndex(PointID v1, PointID v2, PointID v3);
        
    int getQuadIndex(PointID v1, PointID v2, PointID v3,  PointID v4);

    int getTetrahedronIndex(PointID v1, PointID v2, PointID v3, PointID v4);

    int getHexahedronIndex(PointID v1, PointID v2, PointID v3, PointID v4, PointID v5, PointID v6, PointID v7, PointID v8);
    
    int getVertexIndexInTriangle(const Triangle &t, PointID vertexIndex) const;

    int getEdgeIndexInTriangle(const TriangleEdges &t, EdgeID edgeIndex) const;

    int getVertexIndexInQuad(Quad &t, PointID vertexIndex) const;

    int getEdgeIndexInQuad(QuadEdges &t, EdgeID edgeIndex) const;

    int getVertexIndexInTetrahedron(const Tetra &t, PointID vertexIndex) const;

    int getEdgeIndexInTetrahedron(const TetraEdges &t, EdgeID edgeIndex) const;

    int getTriangleIndexInTetrahedron(const TetraTriangles &t, TriangleID triangleIndex) const;

    int getVertexIndexInHexahedron(Hexa &t, PointID vertexIndex) const;

    int getEdgeIndexInHexahedron(const HexaEdges &t, EdgeID edgeIndex) const;

    int getQuadIndexInHexahedron(const HexaQuads &t, QuadID quadIndex) const;

    Edge getLocalTetrahedronEdges (const unsigned int i) const;

    int revision;

    Data< bool > _draw;

    void invalidate();
    
    virtual void updateEdges()     { }
    virtual void updateTriangles() { }
    virtual void updateQuads()     { }
    virtual void updateTetras()    { }
    virtual void updateHexas()     { }

    protected:
        virtual void loadFromMeshLoader(sofa::component::MeshLoader* loader);
};

} // namespace topology

} // namespace component

} // namespace sofa

#endif