include/del_interface.hpp

Go to the documentation of this file.

//-----------------------------------------------------------





#ifndef DEL_INTERFACE
#define DEL_INTERFACE

#include <dpoint.hpp>
#include <vector>
#include <string>

namespace tpp {




class Delaunay {
public:

        typedef  reviver::dpoint <double, 2> Point; 

private:
        
        std::vector< Point >  PList;
        void *in;                                       
        void *delclass;                         
        void *pmesh;                            
        void *pbehavior;
        bool Triangulated;

        void Triangulate(std::string& triswitches);

public:

        Delaunay(std::vector< Point >& v){
                PList.assign(v.begin(), v.end());
                Triangulated = false;
        }


        void Triangulate() { std::string s = "vzQ"; Triangulate( s ); } ;


        void writeoff(std::string& fname);


        int nedges();
        

        int ntriangles();




        int nvertices();


        int hull_size();


        ~Delaunay();

        //
        // Vertex Iterator
        //

        class vIterator {
                private:
                        vIterator(Delaunay *);  
                        Delaunay *MyDelaunay;     

                        void *vloop;              

                public:
                        vIterator operator++();
                        vIterator():vloop(NULL) {};
                        Point &operator*() const; 
                        ~vIterator();

                friend class Delaunay;
                friend bool operator==(vIterator const &, vIterator const &);
                friend bool operator!=(vIterator const &, vIterator const &);
        };
        
    vIterator vbegin(){ return vIterator(this);} ;
        vIterator vend();

        int vertexId(vIterator const &);

        const Point& point_at_vertex_id(int i) {return PList[i];};


        friend class vIterator; 


        //
        // Face Iterator
        //

        class fIterator {
                private:

                                        struct tdata {
                                                double ***tri;
                                                int orient;
                                        };

                                        typedef struct tdata  poface;

                        fIterator(Delaunay *);  
                        Delaunay *MyDelaunay;     

                        //void *floop;              //! Triangles Internal data.
                                                poface floop;
                                                
                public:
                        void operator++();
                                                fIterator() {floop.tri = NULL;};
                                    ~fIterator();

                friend class Delaunay;
                friend bool operator==(fIterator const &, fIterator const &);
                friend bool operator!=(fIterator const &, fIterator const &);
        };

        fIterator fbegin(){ return fIterator(this);     } ;
        fIterator fend();
        int faceId(fIterator const &);



        int Org (fIterator const & fit);


        int Dest(fIterator const & fit);


        int Apex(fIterator const & fit);



        int Sym(fIterator const & fit, char i);



        fIterator Sym(fIterator const & fit);



        inline bool empty(fIterator const & fit)
                { return fit.floop.tri == NULL; };


        bool isdummy(fIterator const & fit);


     

        fIterator Lnext(fIterator const & fit);


        fIterator Lprev(fIterator const & fit);


        fIterator Onext(fIterator const & fit);

        

        fIterator Oprev(fIterator const & fit);


// TODO List: (for face iterators)
/*  dnext:  Find the next edge counterclockwise with the same destination.   */
/*  dnext(abc) -> *ba                                                        */
/*                                                                           */
/*  dprev:  Find the next edge clockwise with the same destination.          */
/*  dprev(abc) -> cb*                                                        */
/*                                                                           */
/*  rnext:  Find the next edge (counterclockwise) of the adjacent triangle.  */
/*  rnext(abc) -> *a*                                                        */
/*                                                                           */
/*  rprev:  Find the previous edge (clockwise) of the adjacent triangle.     */
/*  rprev(abc) -> b**                                                        */




        void trianglesAroundVertex(int vertexid, std::vector<int>& ivv );


        double area(fIterator const & fit);




        fIterator locate(int vertexid);



    friend class fIterator;


}; // Class delaunay

} // namespace tpp ends.

#endif

---