include/shape/tpl3d.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * TopologyCurve
 * 2008-05-16
 * Julien Wintz & Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_topology_surface_hpp_H
# define shape_topology_surface_hpp_H

# include <shape/graphic.hpp>
# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>
# include <shape/kdtree.hpp>
# include <shape/list.hpp>
# include <shape/topology.hpp>
# include <shape/bcell3d_factory.hpp>
# include <algorithm>

# define TMPL   template<class C,class V>
# define TMPL1  template<class V>
# define Viewer viewer<axel,V>
# define SELF   tpl3d<C,V> 

namespace mmx {
namespace shape {

//--------------------------------------------------------------------
struct tpl3d_def {};

template<>
struct use<tpl3d_def>
        :public use<topology_def>
        ,public use<surface_def>
{

    typedef graphic<double> Graphic;


    //--------------------------------------------------------------------
    template<class VIEWER, class TOPOLOGY>
    static VIEWER& print_as_graphic(VIEWER& out, const TOPOLOGY& tp) {

        typedef typename TOPOLOGY::Point  Point;
        typedef typename TOPOLOGY::Edge   Edge;
        typedef typename TOPOLOGY::Face   Face;

        out<<"<mesh type=\"off\" color=\"255 10 0\">\n";
        out<< tp.nbv() <<" "<< tp.nbe() <<" "<< tp.nbf() <<"\n";

        foreach(Point* p, tp.vertices()) {
            out <<" "<<p->x()<<" "<<p->y()<<" "<<p->z()<<"\n";
        }
        foreach(Edge* e, tp.edges()) {
            out <<e->source()->index()<<" "<<e->destination()->index()<<"\n";
        }

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

        return out;
    }
};
//--------------------------------------------------------------------
TMPL  class bcell_list ;
TMPL1 class surface ;
template <class CELL> class node;
template <class CELL> class kdtree;

//--------------------------------------------------------------------  
template<class C,class V=default_env>
class tpl3d : public topology<C,V> {
public:
    typedef topology<C,V> Topology;
    typedef REF_OF(V)     Ref;
    typedef typename Topology::Point    Point;
    typedef typename Topology::Edge     Edge;
    typedef typename Topology::Face     Face;
    typedef bcell<C,Ref>        Cell;
    //typedef bcell3d<C,Ref>      Cell3d;
    typedef surface<Ref>       Surface;
    typedef typename Cell::BoundingBox         BoundingBox;

    tpl3d();
    tpl3d(const BoundingBox & bx);
    ~tpl3d(void) ;

    virtual void clear();

    virtual void insert(Point*);
    virtual void insert_edge(Point*, Point*);
    virtual void insert(Edge *);
    virtual void insert(Face *);

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

    virtual void insert_singular(Point*);
    virtual void insert_singular(BoundingBox*);

    int nbv() const { return m_vertices.size(); }
    int nbe() const { return m_edges.size(); }
    int 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] ; }

    //  protected:
    bool insert_regular (Cell * bcell);

    //private:

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

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

}

TMPL SELF::tpl3d(const BoundingBox & bx) : m_nbv(0), Topology(bx) {
}

TMPL SELF::~tpl3d(void) {
}


TMPL bool 
SELF::insert_regular(Cell* cl) {
    //  m_leaves <<cl;// put in the leaves and will be treated at the end
    return cl->insert_regular(this);
    //  return true;
}


TMPL void 
SELF::insert(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(p1);
    if (p2->index()<0) this->insert(p2);
    m_edges<< new Edge(p1,p2);
}


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

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

TMPL void 
SELF::insert_singular(BoundingBox * ) {
}

TMPL void 
SELF::insert_singular(Point * ) {
    //  m_specials<<p;
}

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

//--------------------------------------------------------------------
TMPL Viewer&
operator<<(Viewer& out, const SELF& tp) {
    use<tpl3d_def,C,V>::print_as_graphic(out,tp);
    return out;
}
TMPL Viewer&
operator<<(Viewer& out, SELF* tp) {
    use<tpl3d_def,C,V>::print_as_graphic(out,*tp);
    return out;
}
//--------------------------------------------------------------------
TMPL graphic<C,V>*
as_graphic(const SELF& tp) {

    typedef graphic<C,V>          Graphic;
    typedef typename SELF::Point  Point;
    typedef typename SELF::Edge   Edge;
    typedef typename SELF::Face   Face;

    //int nbi=0;

    Graphic* res = new Graphic (tp.nbv(), tp.nbe(), tp.nbf());

    int c=0;

    foreach(Point* p, tp.vertices()) {
        res->vertices[c]  =p->x();
        res->vertices[c+1]=p->y();
        res->vertices[c+2]=p->z();
        c+=3;
    }

    if( tp.nbe()>0){
        //nbi=2*tp.nbe();
        int c=0;
        foreach(Edge* e, tp.edges()) {
            res->edges[c]   = e->source()->index();
            res->edges[c+1] = e->destination()->index();
            c+=2;
        }
    }

    if( tp.nbf()>0){
        int c=0;
        foreach(Face* f, tp.faces()) {
            res->faces[c]   = f->points(0)->index();
            res->faces[c+1] = f->points(1)->index();
            res->faces[c+2] = f->points(2)->index();
            c+=3;
        }
    }
    return res;

}
//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL
# undef TMPL1
# undef AlgebraicCurve 
# undef AlgebraicSurface
# undef Cell
# undef Cell3dAlgebraicCurve
# undef Cell3dAlgebraicSurface
# undef Cell3dParametricCurve
# undef Cell3dList
# undef Cell3dFactory
# undef Shape
# undef Viewer
# undef Graphic
# undef SELF 
# endif

---