include/shape/mesh3d.hpp

Go to the documentation of this file.

#ifndef SHAPE_MESH3D_HPP
#define SHAPE_MESH3D_HPP

# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>

# define TMPL   template<class C,class V>
# define SELF   mesh3d<C,V>


namespace mmx { namespace shape {

//--------------------------------------------------------------------
struct mesh3d_def {};

TMPL class mesh3d; // TMPL struct mesh3d;

template<class C>
struct use<mesh3d_def,C>
{
    typedef vertex<C>                  Point;
    typedef edge<C,default_env,Point>  Edge;
    typedef face<C,default_env,Point>  Face;
    typedef mesh3d<C,default_env>                  Mesh;
};

//--------------------------------------------------------------------
template<class C,class V=default_env>
class mesh3d {
public:

    typedef typename use<mesh3d_def,C,V>::Point    Point;
    typedef typename use<mesh3d_def,C,V>::Edge     Edge;
    typedef typename use<mesh3d_def,C,V>::Face     Face;

    mesh3d();
    ~mesh3d(void) ;

    virtual void clear();

    virtual void insert_vertex(Point*);
    virtual void insert_edge(Point*, Point*);
    virtual void insert_edge(Edge *);
    virtual void insert_face(Face *);
    virtual void insert_face(Point*, Point*, Point*);
    virtual void insert_face(Point*, Point*, Point*, Point*);

    void push_back_vertex(Point* p) {this->insert_vertex(p);}
    void push_back_edge(int b, int e) {this->insert_edge(this->vertex(b), this->vertex(e));}

    unsigned nbv() const { return m_vertices.size(); }
    unsigned nbe() const { return m_edges.size(); }
    unsigned nbf() const { return m_faces.size(); }

    inline Seq<Point *> vertices(void) const { return m_vertices ; }
    inline Seq<Edge *>  edges(void)    const { return m_edges ; }
    inline Seq<Face *>  faces(void)    const { return m_faces ; }

    virtual Point* vertex(int i)     { return m_vertices[i] ; }
    virtual Edge*  edge  (int i)      { return m_edges[i] ; }
    virtual Face*  face  (int i)      { return m_faces[i] ; }

    //private:

    Seq<Point *>        m_vertices ;
    Seq<Edge  *>        m_edges ;
    Seq<Face  *>        m_faces ;

    int                 m_nbv;
};
//--------------------------------------------------------------------
TMPL SELF::mesh3d(void) : m_nbv(0) {

}

TMPL SELF::~mesh3d(void) {
}

TMPL void
SELF::insert_vertex(Point * p) {
    //use<point_def,C,V>::point_insertor(m_vertices, p);
    if (p->index()<0) {
        p->set_index(m_nbv);
        m_vertices << p;
        m_nbv++;
    }
}


TMPL void
SELF::insert_edge(Point * p1, Point * p2) {
    if (p1->index()<0) this->insert_vertex(p1);
    if (p2->index()<0) this->insert_vertex(p2);
    m_edges<< new Edge(p1,p2);
}


TMPL void
SELF::insert_edge(Edge* e) {
    m_edges<<e;
}

TMPL void
SELF::insert_face(Face * f) {
    m_faces<<f;
}

TMPL void
SELF::insert_face(Point * p1, Point* p2, Point* p3) {
    Face* f= new Face;
    if (p1->index()<0) this->insert_vertex(p1);
    if (p2->index()<0) this->insert_vertex(p2);
    if (p3->index()<0) this->insert_vertex(p3);
    f->insert(p1);
    f->insert(p2);
    f->insert(p3);
    m_faces<<f;
}

TMPL void
SELF::insert_face(Point * p1, Point* p2, Point* p3, Point* p4) {
    Face* f= new Face;
    if (p1->index()<0) this->insert_vertex(p1);
    if (p2->index()<0) this->insert_vertex(p2);
    if (p3->index()<0) this->insert_vertex(p3);
    if (p4->index()<0) this->insert_vertex(p4);
    f->insert(p1);
    f->insert(p2);
    f->insert(p3);
    f->insert(p4);
    m_faces<<f;
}

TMPL void
SELF::clear() {
    // Should we clean up these points?
    m_faces.resize( 0 );
    m_edges.resize( 0 );
    m_vertices.resize( 0 );
}

//--------------------------------------------------------------------
template<class VIEWER, class C, class V>
VIEWER& print_as_axl(VIEWER& out, const SELF& tp, unsigned d=0) {

    typedef typename SELF::Point  Point;
    typedef typename SELF::Edge   Edge;
    typedef typename SELF::Face   Face;

    if (d<1 && tp.nbv()>0){
        out<<"<pointset color=\"rgb\">\n";
        out<<"<numberofpoints>"<<tp.nbv()<<"</numberofpoints>\n";
        out<<"<points>\n";
        foreach(Point* p, tp.vertices()) {
            out <<" "<<p->x()<<" "<<p->y()<<" "<<p->z()<<" 75 75 255\n";
        }
        out<<"</points>\n";
        out<<" </pointset>\n ";
    }


    if (d<2 && tp.nbe()>0){
        out<<" <curve type=\"mesh\">\n<vect>\nVECT\n";
        out<<tp.nbe()<<" "
          <<2*tp.nbe()<<" "
         <<tp.nbe()<<"\n";

        for(unsigned i=0; i<tp.nbe();i++) out<<"2 ";
        out<<"\n";
        for(unsigned i=0; i<tp.nbe();i++) out<<"1 ";
        out<<"\n";
        foreach(Edge* e, tp.edges()) {
            out <<e->source()->x()<<" "<<e->source()->y()<<"  "<<e->source()->z()<<" "
               <<e->destination()->x()<<" "<<e->destination()->y()<<" "<<e->destination()->z()
              <<"\n";
        }
        for(unsigned i=0; i<tp.edges().size();i++)
            out<< "0.814 0.279 0.2 1\n";
        out<<" </vect>\n </curve>\n";
    }

    if(tp.nbf()>0) {
        std::map<Point*,int> index;
        int c=0;
        foreach(Point* p, tp.vertices()) {
            index[p]=c;c++;
        }

        out<<"<mesh type=\"off\" color=\"255 10 0\">\n";
        out<<c<<" "<<tp.nbf()<<" 0\n";
        foreach(Point* p, tp.vertices()) {
            out <<p->x()<<" "<<p->y()<<" "<<p->z()<<" \n";
        }

        foreach(Face* f, tp.faces()) {
            //      out<<"3 ";
            out<<f->size()<<" ";
            int n=0;
            foreach(Point* p, f->points())
                //      if (n<3)
            {
                out <<index[p]<<" ";
                n++;
            }
            out <<"\n";
        }
        out<<"</mesh>\n";
    }

    return out;
}
//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL
# undef SELF
# endif // SHAPE_MESH3D_HPP

---