TetrahedronSetTopologyContainer.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_TETRAHEDRONSETTOPOLOGYCONTAINER_H     
#define SOFA_COMPONENT_TOPOLOGY_TETRAHEDRONSETTOPOLOGYCONTAINER_H

#include <sofa/component/topology/TriangleSetTopologyContainer.h>

namespace sofa
{

namespace component
{

namespace topology
{
    class TetrahedronSetTopologyModifier;

    using core::componentmodel::topology::BaseMeshTopology;

    typedef BaseMeshTopology::PointID           PointID;
    typedef BaseMeshTopology::EdgeID            EdgeID;
    typedef BaseMeshTopology::TriangleID        TriangleID;
    typedef BaseMeshTopology::TetraID           TetraID;
    typedef BaseMeshTopology::Edge              Edge;
    typedef BaseMeshTopology::Triangle          Triangle;
    typedef BaseMeshTopology::Tetra             Tetra;
    typedef BaseMeshTopology::SeqTetras         SeqTetras;
    typedef BaseMeshTopology::VertexTetras      VertexTetras;
    typedef BaseMeshTopology::EdgeTetras        EdgeTetras;
    typedef BaseMeshTopology::TriangleTetras    TriangleTetras;
    typedef BaseMeshTopology::TetraEdges        TetraEdges;
    typedef BaseMeshTopology::TetraTriangles    TetraTriangles;

    typedef Tetra           Tetrahedron;
    typedef TetraEdges      TetrahedronEdges;
    typedef TetraTriangles  TetrahedronTriangles;

    class TetrahedronSetTopologyContainer : public TriangleSetTopologyContainer 
    {
        friend class TetrahedronSetTopologyModifier;
        
    public:
        typedef Tetra           Tetrahedron;
        typedef TetraEdges      TetrahedronEdges;
        typedef TetraTriangles  TetrahedronTriangles;

        TetrahedronSetTopologyContainer();

        TetrahedronSetTopologyContainer(const sofa::helper::vector< Tetrahedron >& tetrahedra );

        virtual ~TetrahedronSetTopologyContainer(){}

        virtual void clear();
        virtual void addTetra( int a, int b, int c, int d );

        virtual void init();
        

        const SeqTetras& getTetras()   
        { 
            return getTetrahedronArray(); 
        }

        const TetraEdges& getEdgeTetraShell(TetraID i) 
        { 
            return getTetrahedronEdges(i); 
        }

        const TetraTriangles& getTriangleTetraShell(TetraID i) 
        {
            return getTetrahedronTriangles(i); 
        }

        const VertexTetras& getTetraVertexShell(PointID i) 
        {
            return getTetrahedronVertexShell(i); 
        }

        const EdgeTetras& getTetraEdgeShell(EdgeID i) 
        {
            return getTetrahedronEdgeShell(i); 
        }

        const TriangleTetras& getTetraTriangleShell(TriangleID i) 
        {
            return getTetrahedronTriangleShell(i); 
        }

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

        virtual Edge getLocalTetrahedronEdges (const unsigned int i) const;


        virtual bool checkTopology() const;

        unsigned int getNumberOfTetrahedra() const;

        const sofa::helper::vector<Tetrahedron> &getTetrahedronArray();

        const sofa::helper::vector< sofa::helper::vector<unsigned int> > &getTetrahedronVertexShellArray() ;

        const sofa::helper::vector< unsigned int > &getTetrahedronVertexShell(const unsigned int i);

        const sofa::helper::vector< TetrahedronEdges > &getTetrahedronEdgeArray() ;

        const TetrahedronEdges &getTetrahedronEdges(const unsigned int i) ;

        const sofa::helper::vector< TetrahedronTriangles > &getTetrahedronTriangleArray() ;

        const TetrahedronTriangles &getTetrahedronTriangles(const unsigned int i) ;

        const sofa::helper::vector< sofa::helper::vector<unsigned int> > &getTetrahedronEdgeShellArray() ;

        const sofa::helper::vector< unsigned int > &getTetrahedronEdgeShell(const unsigned int i) ;

        const sofa::helper::vector< sofa::helper::vector<unsigned int> > &getTetrahedronTriangleShellArray() ;

        const sofa::helper::vector< unsigned int > &getTetrahedronTriangleShell(const unsigned int i) ;

        int getVertexIndexInTetrahedron(const Tetrahedron &t,unsigned int vertexIndex) const;

        int getEdgeIndexInTetrahedron(const TetrahedronEdges &t,unsigned int edgeIndex) const;

        int getTriangleIndexInTetrahedron(const TetrahedronTriangles &t,unsigned int triangleIndex) const;

        inline friend std::ostream& operator<< (std::ostream& out, const TetrahedronSetTopologyContainer& t)
        {
            out  << t.m_tetrahedron<< " "
                << t.m_tetrahedronEdge<< " "
                << t.m_tetrahedronTriangle;

            out << " "<< t.m_tetrahedronVertexShell.size();
            for (unsigned int i=0;i<t.m_tetrahedronVertexShell.size();i++)
            {
                out << " " << t.m_tetrahedronVertexShell[i];
            }
            out <<" "<< t.m_tetrahedronEdgeShell.size();
            for (unsigned int i=0;i<t.m_tetrahedronEdgeShell.size();i++)
            {
                out << " " << t.m_tetrahedronEdgeShell[i];
            }
            out <<" "<< t.m_tetrahedronTriangleShell.size();
            for (unsigned int i=0;i<t.m_tetrahedronTriangleShell.size();i++)
            {
                out << " " << t.m_tetrahedronTriangleShell[i];
            }
            return out;
        }

        inline friend std::istream& operator>>(std::istream& in, TetrahedronSetTopologyContainer& t)
        {
            unsigned int s;
            sofa::helper::vector< unsigned int > value;


            in >> t.m_tetrahedron >> t.m_tetrahedronEdge >> t.m_tetrahedronTriangle;


            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> value;
                t.m_tetrahedronVertexShell.push_back(value);
            }
            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> value;
                t.m_tetrahedronEdgeShell.push_back(value);
            }
            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> value;
                t.m_tetrahedronTriangleShell.push_back(value);
            }
            return in;
        }

    protected:
        virtual void createEdgeSetArray();

        virtual void createTriangleSetArray();

        virtual void createTetrahedronSetArray();

        bool hasTetrahedra() const;

        bool hasTetrahedronEdges() const;

        bool hasTetrahedronTriangles() const;

        bool hasTetrahedronVertexShell() const;

        bool hasTetrahedronEdgeShell() const;

        bool hasTetrahedronTriangleShell() const;

        void clearTetrahedra();

        void clearTetrahedronEdges();

        void clearTetrahedronTriangles();

        void clearTetrahedronVertexShell();

        void clearTetrahedronEdgeShell();

        void clearTetrahedronTriangleShell();

    private:
        void createTetrahedronEdgeArray();

        void createTetrahedronTriangleArray();

        void createTetrahedronVertexShellArray();

        void createTetrahedronEdgeShellArray();

        void createTetrahedronTriangleShellArray();

        sofa::helper::vector< unsigned int > &getTetrahedronVertexShellForModification(const unsigned int vertexIndex); 
        
        sofa::helper::vector< unsigned int > &getTetrahedronEdgeShellForModification(const unsigned int edgeIndex); 


    protected:
        sofa::helper::vector<Tetrahedron> m_tetrahedron;
        sofa::helper::vector<TetrahedronEdges> m_tetrahedronEdge;
        sofa::helper::vector<TetrahedronTriangles> m_tetrahedronTriangle;

        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_tetrahedronVertexShell;
        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_tetrahedronEdgeShell;
        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_tetrahedronTriangleShell;

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

} // namespace topology

} // namespace component

} // namespace sofa

#endif