QuadSetTopologyContainer.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_QUADSETTOPOLOGYCONTAINER_H
#define SOFA_COMPONENT_TOPOLOGY_QUADSETTOPOLOGYCONTAINER_H

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

namespace sofa
{
namespace component
{
namespace topology
{
    class QuadSetTopologyModifier;

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

    typedef BaseMeshTopology::PointID           PointID;
    typedef BaseMeshTopology::EdgeID            EdgeID;
    typedef BaseMeshTopology::QuadID            QuadID;
    typedef BaseMeshTopology::Edge              Edge;
    typedef BaseMeshTopology::Quad              Quad;
    typedef BaseMeshTopology::SeqQuads          SeqQuads;
    typedef BaseMeshTopology::QuadEdges         QuadEdges;
    typedef BaseMeshTopology::VertexQuads       VertexQuads;
    typedef BaseMeshTopology::EdgeQuads         EdgeQuads;

    class QuadSetTopologyContainer : public EdgeSetTopologyContainer 
    {
        friend class QuadSetTopologyModifier;
        
    public:
        QuadSetTopologyContainer();

        QuadSetTopologyContainer(const sofa::helper::vector< Quad >& quads );

        virtual ~QuadSetTopologyContainer() {}

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

        virtual void init();


        const SeqQuads& getQuads()   
        { 
            return getQuadArray(); 
        }

        const QuadEdges& getEdgeQuadShell(QuadID i) 
        { 
            return getQuadEdge(i); 
        }       

        virtual const VertexQuads& getQuadVertexShell(PointID i);

        virtual const EdgeQuads& getQuadEdgeShell(EdgeID i);

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


        virtual bool checkTopology() const;

        const sofa::helper::vector<Quad> &getQuadArray();

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

        const sofa::helper::vector< QuadEdges > &getQuadEdgeArray() ;

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

        unsigned int getNumberOfQuads() const;

        const QuadEdges &getQuadEdge(const unsigned int i) ;

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

        int getEdgeIndexInQuad(QuadEdges &t,unsigned int edheIndex) const;

        inline friend std::ostream& operator<< (std::ostream& out, const QuadSetTopologyContainer& t)
        {
            out << t.m_quad.size() << " " << t.m_quad << " "
                << t.m_quadEdge.size() << " " << t.m_quadEdge << " "
                << t.m_quadVertexShell.size();
            for (unsigned int i=0; i<t.m_quadVertexShell.size(); i++)
            {
                out << " " << t.m_quadVertexShell[i].size();
                out << " " <<t.m_quadVertexShell[i] ;
            }
            out  << " " << t.m_quadEdgeShell.size();
            for (unsigned int i=0; i<t.m_quadEdgeShell.size(); i++)
            {
                out  << " " << t.m_quadEdgeShell[i].size();
                out  << " " << t.m_quadEdgeShell[i];
            }

            return out;
        }

        inline friend std::istream& operator>>(std::istream& in, QuadSetTopologyContainer& t)
        {
            unsigned int s;
            in >> s;
            for (unsigned int i=0;i<s;i++) 
            {
                Quad T; in >> T;
                t.m_quad.push_back(T);
            }
            in >> s;
            for (unsigned int i=0;i<s;i++) 
            {
                QuadEdges T; in >> T;
                t.m_quadEdge.push_back(T);
            }

            unsigned int sub;
            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> sub;
                sofa::helper::vector< unsigned int > v;
                for (unsigned int j=0;j<sub;j++)
                {
                    unsigned int value;
                    in >> value;
                    v.push_back(value);
                }
                t.m_quadVertexShell.push_back(v);
            }

            in >> s;
            for (unsigned int i=0;i<s;i++)
            {
                in >> sub;
                sofa::helper::vector< unsigned int > v;
                for (unsigned int j=0;j<sub;j++)
                {
                    unsigned int value;
                    in >> value;
                    v.push_back(value);
                }
                t.m_quadEdgeShell.push_back(v);
            }  

            return in;
        }

    protected:
        virtual void createQuadSetArray();

        virtual void createEdgeSetArray();

        bool hasQuads() const;

        bool hasQuadEdges() const;

        bool hasQuadVertexShell() const;

        bool hasQuadEdgeShell() const;

        void clearQuads();

        void clearQuadEdges();

        void clearQuadVertexShell();

        void clearQuadEdgeShell();

    private:
        void createQuadEdgeArray();

        void createQuadVertexShellArray();

        void createQuadEdgeShellArray();

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

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

    protected:
        sofa::helper::vector<Quad> m_quad;
        sofa::helper::vector<QuadEdges> m_quadEdge;
        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_quadVertexShell;
        sofa::helper::vector< sofa::helper::vector< unsigned int > > m_quadEdgeShell;

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

} // namespace topology

} // namespace component

} // namespace sofa

#endif