HexahedronSetTopologyContainer.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                             *
******************************************************************************/

// CONVENTION : indices ordering for the vertices of an hexahedron :
//
//     Y  3---------2
//     ^ /         /|
//     |/         / |
//     7---------6  |
//     |         |  |
//     |  0------|--1
//     | /       | /
//     |/        |/
//     4---------5-->X
//    /
//   /
//  Z

#ifndef SOFA_COMPONENT_TOPOLOGY_HEXAHEDRONSETTOPOLOGYCONTAINER_H
#define SOFA_COMPONENT_TOPOLOGY_HEXAHEDRONSETTOPOLOGYCONTAINER_H

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

namespace sofa
{
namespace component
{
namespace topology
{
    class HexahedronSetTopologyModifier;

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

    typedef BaseMeshTopology::PointID           PointID;
    typedef BaseMeshTopology::EdgeID            EdgeID;
    typedef BaseMeshTopology::TriangleID        QuadID;
    typedef BaseMeshTopology::HexaID            HexaID;
    typedef BaseMeshTopology::Edge              Edge;
    typedef BaseMeshTopology::Quad              Quad;
    typedef BaseMeshTopology::Hexa              Hexa;
    typedef BaseMeshTopology::SeqHexas          SeqHexas;
    typedef BaseMeshTopology::VertexHexas       VertexHexas;
    typedef BaseMeshTopology::EdgeHexas         EdgeHexas;
    typedef BaseMeshTopology::QuadHexas         QuadHexas;
    typedef BaseMeshTopology::HexaEdges         HexaEdges;
    typedef BaseMeshTopology::HexaQuads         HexaQuads;

    typedef Hexa        Hexahedron;
    typedef HexaEdges   HexahedronEdges;
    typedef HexaQuads   HexahedronQuads;

    class HexahedronSetTopologyContainer : public QuadSetTopologyContainer 
    {
        friend class HexahedronSetTopologyModifier;
        
    public:
        typedef Hexa        Hexahedron;
        typedef HexaEdges   HexahedronEdges;
        typedef HexaQuads   HexahedronQuads;

        HexahedronSetTopologyContainer();

        HexahedronSetTopologyContainer(const sofa::helper::vector< Hexahedron > &hexahedra);

        virtual ~HexahedronSetTopologyContainer() {}

        virtual void clear();
        virtual void addHexa( int a, int b, int c, int d, int e, int f, int g, int h );

        virtual void init();


        const SeqHexas& getHexas()   
        {
            return getHexahedronArray(); 
        }
        
        const HexaEdges& getEdgeHexaShell(HexaID i)
        {
            return getHexahedronEdges(i); 
        }

        const HexaQuads& getQuadHexaShell(HexaID i) 
        {
            return getHexahedronQuads(i); 
        }

        const VertexHexas& getHexaVertexShell(PointID i)
        {
            return getHexahedronVertexShell(i); 
        }
        
        const EdgeHexas& getHexaEdgeShell(EdgeID i)
        { 
            return getHexahedronEdgeShell(i); 
        }

        const QuadHexas& getHexaQuadShell(QuadID i)
        { 
            return getHexahedronQuadShell(i); 
        }       

        virtual int getHexahedronIndex(PointID v1, PointID v2, PointID v3, PointID v4, 
                                    PointID v5, PointID v6, PointID v7, PointID v8);


        virtual bool checkTopology() const;

        const sofa::helper::vector<Hexahedron> &getHexahedronArray();

        const Hexahedron &getHexahedron(const unsigned int i);

        unsigned int getNumberOfHexahedra() const;

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

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

        const sofa::helper::vector< HexahedronEdges > &getHexahedronEdgeArray() ;

        const HexahedronEdges &getHexahedronEdges(const unsigned int i) ;

        Edge getLocalHexahedronEdges (const unsigned int i) const;

        const sofa::helper::vector< HexahedronQuads > &getHexahedronQuadArray() ;

        const HexahedronQuads &getHexahedronQuads(const unsigned int i) ;

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

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


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

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

        int getVertexIndexInHexahedron(Hexahedron &t,unsigned int vertexIndex) const;

        int getEdgeIndexInHexahedron(const HexahedronEdges &t,unsigned int edgeIndex) const;

        int getQuadIndexInHexahedron(const HexahedronQuads &t,unsigned int quadIndex) const;

        inline friend std::ostream& operator<< (std::ostream& out, const HexahedronSetTopologyContainer& t)
        {
            out  << t.m_hexahedron<< " "
                << t.m_hexahedronEdge<< " "
                << t.m_hexahedronQuad;

            out << " "<< t.m_hexahedronVertexShell.size();
            for (unsigned int i=0;i<t.m_hexahedronVertexShell.size();i++)
            {
                out << " " << t.m_hexahedronVertexShell[i];
            }
            out <<" "<< t.m_hexahedronEdgeShell.size();
            for (unsigned int i=0;i<t.m_hexahedronEdgeShell.size();i++)
            {
                out << " " << t.m_hexahedronEdgeShell[i];
            }
            out <<" "<< t.m_hexahedronQuadShell.size();
            for (unsigned int i=0;i<t.m_hexahedronQuadShell.size();i++)
            {
                out << " " << t.m_hexahedronQuadShell[i];
            }
            return out;
        }

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


            in >> t.m_hexahedron >> t.m_hexahedronEdge >> t.m_hexahedronQuad;


            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> value;
                t.m_hexahedronVertexShell.push_back(value);
            }
            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> value;
                t.m_hexahedronEdgeShell.push_back(value);
            }
            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> value;
                t.m_hexahedronQuadShell.push_back(value);
            }
            return in;
        }

    protected:
        virtual void createEdgeSetArray();

        virtual void createQuadSetArray();

        virtual void createHexahedronSetArray();

        bool hasHexahedra() const;

        bool hasHexahedronEdges() const;

        bool hasHexahedronQuads() const;

        bool hasHexahedronVertexShell() const;

        bool hasHexahedronEdgeShell() const;

        bool hasHexahedronQuadShell() const;

        void clearHexahedra();

        void clearHexahedronEdges();

        void clearHexahedronQuads();

        void clearHexahedronVertexShell();

        void clearHexahedronEdgeShell();

        void clearHexahedronQuadShell();

    private:
        void createHexahedronEdgeArray();

        void createHexahedronQuadArray();

        void createHexahedronVertexShellArray();

        void createHexahedronEdgeShellArray();

        void createHexahedronQuadShellArray();

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

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

    protected:
        sofa::helper::vector<Hexahedron> m_hexahedron;
        sofa::helper::vector<HexahedronEdges> m_hexahedronEdge;
        sofa::helper::vector<HexahedronQuads> m_hexahedronQuad;

        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_hexahedronVertexShell;
        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_hexahedronEdgeShell;
        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_hexahedronQuadShell;
        virtual void loadFromMeshLoader(sofa::component::MeshLoader* loader);
    };

} // namespace topology

} // namespace component

} // namespace sofa

#endif