BaseMesh.h

Go to the documentation of this file.

#ifndef _MESHLIB_BASE_MESH_H_
#define _MESHLIB_BASE_MESH_H_

#define MAX_LINE 2048

#include <math.h>
#include <assert.h>
#include <iostream>
#include <fstream>
#include <list>
#include <map>

#include "../Geometry/Point.h"
#include "../Geometry/Point2.h"
#include "../Parser/StrUtil.h"
#include "edge.h" //for CEdgeKey class definition

namespace MeshLib{

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class CBaseMesh
{
public:
        // pointer to Vertices, Halfedges, Edges, Face and Solid
        typedef CVertex   * tVertex;
        typedef CHalfEdge * tHalfEdge;
        typedef CEdge     * tEdge;
        typedef CFace     * tFace;

        //constructor and destructor
        CBaseMesh(){};
        ~CBaseMesh();

        //copy operator
        void copy( CBaseMesh & mesh );

        //file io
        void read_obj(  const char * filename );
        void write_obj( const char * output);

        void read_m(  const char * input );
        void write_m( const char * output);
        
        void read_off( const char * input );

        //number of vertices, faces, edges
        int  numVertices();
        int  numEdges();
        int  numFaces();

        //is boundary
        bool    isBoundary( tVertex  v );
        bool    isBoundary( tEdge    e );
        bool    isBoundary( tHalfEdge  he );

        //acess vertex - id
        tVertex idVertex( int id );
        int     vertexId( tVertex  v );

        //access face - id
        tFace   idFace( int id );
        int     faceId( tFace  f );

        //access edge - edge key, vertex
        tEdge   vertexEdge( tVertex v0, tVertex v1 );

        //access halfedge - halfedge key, vertex
        tHalfEdge   vertexHalfedge( tVertex v0, tVertex v1 );
        tHalfEdge   corner( tVertex v, tFace f);

        //halfedge->face
        tFace   halfedgeFace( tHalfEdge he );
        //halfedge->vertex
        tVertex halfedgeVertex( tHalfEdge he );
        //halfedge->vertex
        tVertex halfedgeTarget( tHalfEdge he );
        //halfedge->vertex
        tVertex halfedgeSource( tHalfEdge he );

        //halfedge->next
        tHalfEdge   halfedgeNext( tHalfEdge he );
        //halfedge->prev
        tHalfEdge   halfedgePrev( tHalfEdge he );
        //halfedge->sym
        tHalfEdge   halfedgeSym( tHalfEdge he );
        //halfedge->edge
        tEdge       halfedgeEdge( tHalfEdge he );
        //v->halfedge
        tHalfEdge   vertexHalfedge( tVertex v );

        //edge->vertex
        tVertex edgeVertex1( tEdge  e );
        tVertex edgeVertex2( tEdge  e );

        //edge->face
        tFace edgeFace1( tEdge  e );
        tFace edgeFace2( tEdge  e );

        //edge->halfedge
        tHalfEdge edgeHalfedge( tEdge  e, int id);

        //face->halfedge
        tHalfEdge faceHalfedge( tFace f );

        //Euler operations
        tHalfEdge vertexMostClwOutHalfEdge( tVertex  v );
        tHalfEdge vertexNextCcwOutHalfEdge( tHalfEdge  he );

        tHalfEdge vertexMostCcwOutHalfEdge( tVertex  v );
        tHalfEdge vertexNextClwOutHalfEdge( tHalfEdge  he );

        tHalfEdge vertexMostClwInHalfEdge( tVertex  v );
        tHalfEdge vertexNextCcwInHalfEdge( tHalfEdge  he );

        tHalfEdge vertexMostCcwInHalfEdge( tVertex  v );
        tHalfEdge vertexNextClwInHalfEdge( tHalfEdge  he );

        tHalfEdge faceMostClwHalfEdge( tFace  face );
        tHalfEdge faceMostCcwHalfEdge( tFace  face );
        tHalfEdge faceNextCcwHalfEdge( tHalfEdge  he );
        tHalfEdge faceNextClwHalfEdge( tHalfEdge  he );


        double edgeLength( tEdge e );

        std::list<tEdge>   & edges()            { return m_edges; };
        std::list<tFace>   & faces()            { return m_faces; };
        std::list<tVertex> & vertices() { return m_verts; };
/*
        bool with_uv() { return m_with_texture; };
        bool with_normal() { return m_with_normal; };
*/
protected:

  std::list<tEdge>                          m_edges;
  std::list<tVertex>                        m_verts;
  std::list<tFace>                                                      m_faces;

  //maps

  std::map<int, tVertex>                    m_map_vert;
  std::map<int, tFace>                                          m_map_face;
  std::map<CEdgeKey, tEdge>                                     m_map_edge;


public:
        tVertex   createVertex(   int id = 0 );
        tEdge     createEdge(   tVertex v1, tVertex v2 );
        tFace     createFace(   tVertex  v[], int id ); //create a triangle

        void      deleteFace( tFace  pFace );
        
        bool      m_with_texture;
        bool      m_with_normal;

};



template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::edgeVertex1( tEdge   e )
{
        assert( e->halfedge(0 ) != NULL );
        return (CVertex*)e->halfedge(0)->source();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex *  CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::edgeVertex2( tEdge   e )
{
        assert( e->halfedge(0 ) != NULL );
        return (CVertex*)e->halfedge(0)->target();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CFace * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::edgeFace1( tEdge   e )
{
        assert( e->halfedge(0) != NULL );
        return (CFace*) e->halfedge(0)->face();
};

//access he->f
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::edgeHalfedge( tEdge   e, int id )
{
        return (CHalfEdge*)e->halfedge(id);
};

//access e->f
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CFace * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::edgeFace2( tEdge   e )
{
        assert( e->halfedge(1) != NULL );
        return (CFace*) e->halfedge(1)->face();
};

//access he->f
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CFace * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeFace( tHalfEdge   he )
{
        return (CFace*)he->face();
};

//access f->he
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::faceHalfedge( tFace   f )
{
        return (CHalfEdge*)f->halfedge();
};


//access he->next
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeNext( tHalfEdge   he )
{
        return (CHalfEdge*)he->he_next();
};

//access he->prev
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgePrev( tHalfEdge  he )
{
        return (CHalfEdge*)he->he_prev();
};

//access he->sym
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeSym( tHalfEdge   he )
{
        return (CHalfEdge*)he->he_sym();
};

//access he->edge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeEdge( tHalfEdge  he )
{
        return (CEdge*)he->edge();
};

//access he->v
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeVertex( tHalfEdge  he )
{
        return (CVertex*)he->vertex();
};

//access he->v
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeTarget( tHalfEdge   he )
{
        return (CVertex*)he->vertex();
};

//access he->v
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::halfedgeSource( tHalfEdge   he )
{
        return (CVertex*)he->he_prev()->vertex();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
bool CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::isBoundary( tVertex   v )
{
        return v->boundary();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
bool CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::isBoundary( tEdge   e )
{
        if( e->halfedge(0) == NULL || e->halfedge(1) == NULL ) return true;
        return false;
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
bool CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::isBoundary( tHalfEdge   he )
{
        if( he->he_sym() == NULL ) return true;
        return false;
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
int CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::numVertices() 
{
        return (int) m_verts.size();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
int CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::numEdges() 
{
        return (int) m_edges.size();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
int CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::numFaces() 
{
        return (int) m_faces.size();
};


//Euler operation
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge *  CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexMostClwOutHalfEdge( tVertex   v )
{
        return (CHalfEdge*)v->most_clw_out_halfedge();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexMostCcwOutHalfEdge( tVertex   v )
{
        return (CHalfEdge*)v->most_ccw_out_halfedge();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::corner( tVertex  v, tFace  f)
{
        CHalfEdge * he = faceMostCcwHalfEdge( f );
        do{
                if( he->vertex() == v )
                        return (CHalfEdge*) he;
                he = faceNextCcwHalfEdge( he );
        }while( he != faceMostCcwHalfEdge(f) );
        return NULL;
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexNextCcwOutHalfEdge( tHalfEdge  he )
{
        return (CHalfEdge*) he->ccw_rotate_about_source();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexNextClwOutHalfEdge( tHalfEdge   he )
{
        assert( he->he_sym() != NULL );
        return (CHalfEdge*)he->clw_rotate_about_source();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexMostClwInHalfEdge( tVertex   v )
{
        return (CHalfEdge*)v->most_clw_in_halfedge();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexMostCcwInHalfEdge( tVertex   v )
{
        return (CHalfEdge*)v->most_ccw_in_halfedge();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexNextCcwInHalfEdge( tHalfEdge   he )
{
        assert( he->he_sym() != NULL );
        return (CHalfEdge*)he->ccw_rotate_about_target();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexNextClwInHalfEdge( tHalfEdge   he )
{
        return (CHalfEdge*)he->clw_rotate_about_target();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::faceNextClwHalfEdge( tHalfEdge   he )
{
        return (CHalfEdge*)he->he_prev();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::faceNextCcwHalfEdge( tHalfEdge   he )
{
        return (CHalfEdge*)he->he_next();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge *  CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::faceMostCcwHalfEdge( tFace   face )
{
        return (CHalfEdge*)face->halfedge();
};template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::faceMostClwHalfEdge( tFace   face )
{
        return (CHalfEdge*)face->halfedge()->he_next();
};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::~CBaseMesh()
{
        //remove vertices

  for( std::list<CVertex*>::iterator viter = m_verts.begin(); viter != m_verts.end(); viter ++ )
  {
      CVertex * pV = *viter;
      delete pV;
  }
  m_verts.clear();

        //remove faces

  for( std::list<CFace*>::iterator fiter = m_faces.begin(); fiter != m_faces.end(); fiter ++ )
  {
      CFace * pF = *fiter;

      tHalfEdge he = faceHalfedge( pF );
 
      std::list<CHalfEdge*> hes;
      do{
        he = halfedgeNext( he );
        hes.push_back( he );
      }while( he != pF->halfedge() );

      for( std::list<CHalfEdge*>::iterator hiter = hes.begin(); hiter != hes.end(); hiter ++)
      {
          CHalfEdge * pH = *hiter;
          delete pH;
      }
      hes.clear();

      delete pF;
  }
  m_faces.clear();
        
  //remove edges
  for( std::list<CEdge*>::iterator eiter = m_edges.begin(); eiter != m_edges.end(); eiter ++ )
  {
      CEdge * pE = *eiter;
      delete pE;
  }

  m_edges.clear();
        
  //clear all the maps
  m_map_vert.clear();
  m_map_face.clear();
  m_map_edge.clear();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
double CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::edgeLength( tEdge  e )
{
        CVertex * v1 = edgeVertex1(e);
        CVertex * v2 = edgeVertex2(e);

        return ( v1->point() - v2->point() ).norm();
}


//create new gemetric simplexes
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::createVertex( int id )
{
        CVertex * v = new CVertex();
        assert( v != NULL );
        v->id() = id;
        m_verts.push_back( v );
        m_map_vert.insert( std::pair<int,CVertex*>(id,v));
        return v;
};


template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::read_obj( const char * filename )
{

        std::fstream f(filename, std::fstream::in);
        if( f.fail() ) return;

        char cmd[1024];

        int  vid = 1;
        int  fid = 1;
        
        bool with_uv = false;
        bool with_normal = false;

        std::vector<CPoint2> uvs;
        std::vector<CPoint> normals;


        while ( f.getline( cmd, 1024) )
    {
                std::string line( cmd );
                line = strutil::trim( line );

                strutil::Tokenizer stokenizer( line, " \t\r\n" );

                stokenizer.nextToken();
                std::string token = stokenizer.getToken();
                
                if( token == "v" )
                {
                        CPoint p;
                        for( int i = 0; i < 3; i ++ )
                        {
                                stokenizer.nextToken();
                                token = stokenizer.getToken();
                                p[i] = strutil::parseString<float>(token);
                        }
                        
                        CVertex * v = createVertex( vid);
                        v->point() = p;
                        vid ++;
                        continue;
                }


                if( token == "vt" )
                {
                        with_uv = true;
                        CPoint2 uv;
                        for( int i = 0; i < 2; i ++ )
                        {
                                stokenizer.nextToken();
                                token = stokenizer.getToken();
                                uv[i] = strutil::parseString<float>(token);
                        }
                        uvs.push_back( uv );
                        continue;
                }


                if ( token ==  "vn" )
                {
                        with_normal = true;

                        CPoint n;
                        for( int i = 0; i < 3; i ++ )
                        {
                                stokenizer.nextToken();
                                token = stokenizer.getToken();
                                n[i] = strutil::parseString<float>(token);
                        }
                        normals.push_back( n );
                        continue;
                }




                if ( token == "f" )
                {
                        CVertex* v[3];
                        for( int i = 0 ; i < 3; i ++ )
                        {
                                stokenizer.nextToken();
                                token = stokenizer.getToken();
                                
                                
                                strutil::Tokenizer tokenizer( token, " /\t\r\n" );
                                
                                int ids[3];
                                int k = 0;
                                while( tokenizer.nextToken() )
                                {
                                        std::string token = tokenizer.getToken();
                                        ids[k] = strutil::parseString<int>(token);
                                        k ++;
                                }

                                
                                v[i] = m_map_vert[ ids[0] ];
                                if( with_uv )
                                        v[i]->uv() = uvs[ ids[1]-1 ];
                                if( with_normal )
                                        v[i]->normal() = normals[ ids[2]-1 ];
                        }
                        createFace( v, fid++ );
                }
        }

        f.close();

        //Label boundary edges
        for(std::list<CEdge*>::iterator eiter= m_edges.begin() ; eiter != m_edges.end() ; ++ eiter )
        {
                CEdge *     edge = *eiter;
                CHalfEdge * he[2];

                he[0] = edge->halfedge(0);
                he[1] = edge->halfedge(1);
                
                assert( he[0] != NULL );
                

                if( he[1] != NULL )
                {
                        assert( he[0]->target() == he[1]->source() && he[0]->source() == he[1]->target() );

                        if( he[0]->target()->id() < he[0]->source()->id() )
                        {
                                edge->halfedge(0 ) = he[1];
                                edge->halfedge(1 ) = he[0];
                        }

                        assert( edgeVertex1(edge)->id() < edgeVertex2(edge)->id() );
                }
                else
                {
                        he[0]->vertex()->boundary() = true;
                        he[0]->he_prev()->vertex()->boundary()  = true;
                }

        }

        std::list<CVertex*> dangling_verts;
        //Label boundary edges
        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                tVertex     v = *viter;
                if( v->halfedge() != NULL ) continue;
                dangling_verts.push_back( v );
        }

        for( std::list<CVertex*>::iterator  viter = dangling_verts.begin() ; viter != dangling_verts.end(); ++ viter )
        {
                tVertex v = *viter;
                m_verts.remove( v );
                delete v;
                v = NULL;
        }

        //Arrange the boundary half_edge of boundary vertices, to make its halfedge
        //to be the most ccw in half_edge

        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                tVertex     v = *viter;
                if( !v->boundary() ) continue;

                CHalfEdge * he = v->halfedge();
                while( he->he_sym() != NULL )
                {
                        he = vertexNextCcwInHalfEdge( he );
                }

                v->halfedge() = he;
        }

}

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CFace * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::createFace( tVertex  v[] , int id )
{
          CFace * f = new CFace();
          assert( f != NULL );
          f->id() = id;
          m_faces.push_back( f );
          m_map_face.insert( std::pair<int,tFace>(id,f) );

                //create halfedges
                tHalfEdge hes[3];

                for(int i = 0; i < 3; i ++ )
                {
                        hes[i] = new CHalfEdge;
                        assert( hes[i] );
                        CVertex * vert =  v[i];
                        hes[i]->vertex() = vert;
                        vert->halfedge() = hes[i];
                }

                //linking to each other
                for(int i = 0; i < 3; i ++ )
                {
                        hes[i]->he_next() = hes[(i+1)%3];
                        hes[i]->he_prev() = hes[(i+2)%3];
                }

                //linking to face
                for(int i = 0; i < 3; i ++ )
                {
                        hes[i]->face()   = f;
                        f->halfedge()    = hes[i];
                }

                //connecting with edge
                for(int i = 0; i < 3; i ++ )
                {
                        tEdge e = createEdge( v[i], v[(i+2)%3] );
                        if( e->halfedge(0)  == NULL )
                        {
                                e->halfedge(0) = hes[i];
                        }
                        else
                        {
                                assert( e->halfedge(1) == NULL );
                                e->halfedge(1) = hes[i];
                        }
                        hes[i]->edge() = e;
                }

                return f;
};


//access id->v
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CVertex * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::idVertex( int id ) 
{
        return m_map_vert[id];
};

//access v->id
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
int CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexId( tVertex   v )
{
        return v->id();
};

//access id->f
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CFace * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::idFace( int id )
{
        return m_map_face[id];
};

//acess f->id
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
int CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::faceId( tFace   f )
{
        return f->id();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::createEdge( tVertex  v1, tVertex  v2 )
{
        CEdgeKey key(v1->id(),v2->id());

        CEdge * e = NULL;

        if( m_map_edge.find( key ) != m_map_edge.end() )
        {
                e = m_map_edge[key];
                assert( e!= NULL );
                return e;
        }

        e = new CEdge;
        assert( e != NULL );

        assert( e != NULL );
        m_map_edge.insert( std::pair<CEdgeKey,CEdge *>(key,e) );
        m_edges.push_back( e );
        return e;

};



//access vertex->edge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexEdge( tVertex  v0, tVertex  v1 )
{
        CEdgeKey key(v0->id(),v1->id());
        return m_map_edge[key];
};

//access vertex->edge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexHalfedge( tVertex  v0, tVertex  v1 )
{
        CEdge * e = vertexEdge( v0, v1 );
        assert( e != NULL );
        CHalfEdge * he = (CHalfEdge*) e->halfedge(0);
        if( he->vertex() == v1 && he->he_prev()->vertex() == v0 ) return he;
        he = (CHalfEdge*) e->halfedge(1);
        assert( he->vertex() == v1 && he->he_prev()->vertex() == v0 );
        return he;
};

//access vertex->edge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CHalfEdge * CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::vertexHalfedge( tVertex  v  )
{
        return (CHalfEdge*) v->halfedge();
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::read_m( const char * input )
{
        std::fstream is( input, std::fstream::in );

        if( is.fail() )
        {
                fprintf(stderr,"Error in opening file %s\n", input );
                return;
        }

        char buffer[MAX_LINE];
        int id;

        while( is.getline(buffer, MAX_LINE )  )
        {               
        
                std::string line( buffer );
                line = strutil::trim( line );

                strutil::Tokenizer stokenizer( line, " \r\n" );

                stokenizer.nextToken();
                std::string token = stokenizer.getToken();
        
                if( token == "Vertex"  ) 
                {
                        stokenizer.nextToken();
                        token = stokenizer.getToken();
                        id = strutil::parseString<int>(token);

                        CPoint p;
                        for( int i = 0 ; i < 3; i ++ )
                        {
                                stokenizer.nextToken();
                                token = stokenizer.getToken();
                                p[i] = strutil::parseString<float>(token);
                        }
                
                        tVertex v  = createVertex( id );
                        v->point() = p;
                        v->id()    = id;

                        if( ! stokenizer.nextToken("\t\r\n") ) continue;
                        token = stokenizer.getToken();

                        int sp = (int) token.find("{");
                        int ep = (int) token.find("}");

                        if( sp >= 0 && ep >= 0 )
                        {
                                v->string() = token.substr( sp+1, ep-sp-1 );
                        }
                        continue;
                }
                

                if( token == "Face" ) 
                {

                        stokenizer.nextToken();
                        token = stokenizer.getToken();
                        id = strutil::parseString<int>(token);
        
                        CVertex * v[3];
                        for( int i = 0; i < 3; i ++ )
                        {
                                stokenizer.nextToken();
                                token = stokenizer.getToken();
                                int vid = strutil::parseString<int>(token);
                                v[i] = idVertex( vid );
                        }

                        tFace f = createFace( v, id );

                        if( !stokenizer.nextToken() ) continue;
                        token = stokenizer.getToken();  

                        int sp = (int) token.find("{");
                        int ep = (int) token.find("}");

                        if( sp >= 0 && ep >= 0 )
                        {
                                f->string() = token.substr( sp+1, ep-sp-1 );
                        }
                        continue;
                }

                //read in edge attributes
                if( token == "Edge" )
                {
                        stokenizer.nextToken();
                        token = stokenizer.getToken();
                        int id0 = strutil::parseString<int>( token );

                        stokenizer.nextToken();
                        token = stokenizer.getToken();
                        int id1 = strutil::parseString<int>( token );


                        CVertex * v0 = idVertex( id0 );
                        CVertex * v1 = idVertex( id1 );

                        tEdge edge = vertexEdge( v0, v1 );

                        if( !stokenizer.nextToken("\t\r\n") ) continue;
                        token = stokenizer.getToken();  

                        int sp = (int) token.find("{");
                        int ep = (int) token.find("}");

                        if( sp >= 0 && ep >= 0 )
                        {
                                  edge->string() = token.substr( sp+1, ep-sp-1 );
                        }
                        continue;
                }

                //read in edge attributes
                if( token == "Corner" ) 
                {
                        stokenizer.nextToken();
                        token = stokenizer.getToken();
                        int vid = strutil::parseString<int>( token );

                        stokenizer.nextToken();
                        token = stokenizer.getToken();
                        int fid = strutil::parseString<int>( token );


                        CVertex * v = idVertex( vid );
                        CFace   * f = idFace( fid );
                        tHalfEdge he = corner( v, f );


                        if( !stokenizer.nextToken("\t\r\n") ) continue;
                        token = stokenizer.getToken();  

                        int sp = (int) token.find("{");
                        int ep = (int) token.find("}");

                        if( sp >= 0 && ep >= 0 )
                        {
                                he->string() = token.substr( sp+1, ep-sp-1 );
                        }
                        continue;
                }
        }

        //Label boundary edges
        for(std::list<CEdge*>::iterator eiter= m_edges.begin() ; eiter != m_edges.end() ; ++ eiter )
        {
                CEdge *     edge = *eiter;
                CHalfEdge * he[2];

                he[0] = edgeHalfedge( edge, 0 );
                he[1] = edgeHalfedge( edge, 1 );
                
                assert( he[0] != NULL );
                

                if( he[1] != NULL )
                {
                        assert( he[0]->target() == he[1]->source() && he[0]->source() == he[1]->target() );

                        if( he[0]->target()->id() < he[0]->source()->id() )
                        {
                                edge->halfedge(0 ) = he[1];
                                edge->halfedge(1 ) = he[0];
                        }

                        assert( edgeVertex1(edge)->id() < edgeVertex2(edge)->id() );
                }
                else
                {
                        he[0]->vertex()->boundary() = true;
                        he[0]->he_prev()->vertex()->boundary()  = true;
                }

        }

        std::list<CVertex*> dangling_verts;
        //Label boundary edges
        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                CVertex *     v = *viter;
                if( v->halfedge() != NULL ) continue;
                dangling_verts.push_back( v );
        }

        for( std::list<CVertex*>::iterator  viter = dangling_verts.begin() ; viter != dangling_verts.end(); ++ viter )
        {
                CVertex * v = *viter;
                m_verts.remove( v );
                delete v;
                v = NULL;
        }

        //Arrange the boundary half_edge of boundary vertices, to make its halfedge
        //to be the most ccw in half_edge

        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                CVertex *     v = *viter;
                if( !v->boundary() ) continue;

                CHalfEdge * he = vertexMostCcwInHalfEdge( v );
                while( he->he_sym() != NULL )
                {
                        he =  vertexNextCcwInHalfEdge ( he );
                }
                v->halfedge() = he;
        }

        //read in the traits

        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                CVertex *     v = *viter;
                v->_from_string();
        }

        for(std::list<CEdge*>::iterator eiter = m_edges.begin();  eiter != m_edges.end() ; ++ eiter )
        {
                CEdge *     e = *eiter;
                e->_from_string();
        }

        for(std::list<CFace*>::iterator fiter = m_faces.begin();  fiter != m_faces.end() ; ++ fiter )
        {
                CFace *     f = *fiter;
                f->_from_string();
        }

        for( std::list<CFace*>::iterator fiter=m_faces.begin(); fiter != m_faces.end(); fiter ++ )
        {
                CFace * pF = *fiter;

                CHalfEdge * pH  = faceMostCcwHalfEdge( pF );
                do{
                        pH->_from_string();
                        pH = faceNextCcwHalfEdge( pH );
                }while( pH != faceMostCcwHalfEdge(pF ) );
        }

};
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::write_m( const char * output )
{
        //write traits to string
        for( std::list<CVertex*>::iterator viter=m_verts.begin(); viter != m_verts.end(); viter ++ )
        {
                CVertex * pV = *viter;
                pV->_to_string();
        }

        for( std::list<CEdge*>::iterator eiter=m_edges.begin(); eiter != m_edges.end(); eiter ++ )
        {
                CEdge * pE = *eiter;
                pE->_to_string();
        }

        for( std::list<CFace*>::iterator fiter=m_faces.begin(); fiter != m_faces.end(); fiter ++ )
        {
                CFace * pF = *fiter;
                pF->_to_string();
        }

        for( std::list<CFace*>::iterator fiter=m_faces.begin(); fiter != m_faces.end(); fiter ++ )
        {
                CFace * pF = *fiter;
                CHalfEdge * pH  = faceMostCcwHalfEdge( pF );
                do{
                        pH->_to_string();
                        pH = faceNextCcwHalfEdge( pH );
                }while( pH != faceMostCcwHalfEdge(pF ) );
        }


        std::fstream _os( output, std::fstream::out );
        if( _os.fail() )
        {
                fprintf(stderr,"Error is opening file %s\n", output );
                return;
        }


        //remove vertices
  for( std::list<CVertex*>::iterator viter = m_verts.begin(); viter != m_verts.end(); viter ++)
  {
                tVertex v = *viter;

                _os << "Vertex " << v->id();
                
                for( int i = 0; i < 3; i ++ )
                {
                        _os << " " << v->point()[i];
                }
                if( v->string().size() > 0 )
                {
                        _os << " " <<"{"<< v->string() << "}";
                }
                _os << std::endl;
        }

  for( std::list<CFace*>::iterator fiter = m_faces.begin(); fiter != m_faces.end(); fiter ++ )
        {
                tFace f = *fiter;

                _os << "Face " << f->id();
                tHalfEdge he = faceHalfedge( f );
                do{
                        _os << " " <<  he->target()->id();
                        he = halfedgeNext( he );
                }while( he != f->halfedge() );

                if( f->string().size() > 0 )
                {
                        _os << "{"<< f->string() << "}";
                }
                _os << std::endl;
        }

  for( std::list<CEdge*>::iterator eiter = m_edges.begin(); eiter != m_edges.end(); eiter ++ )
        {
                tEdge e = *eiter;
                if( e->string().size() > 0 )
                {
                        _os << "Edge "<<  edgeVertex1(e)->id() <<" " << edgeVertex2(e)->id() << " ";
                        _os << "{" << e->string() << "}" << std::endl;
                }
        }

  for( std::list<CFace*>::iterator fiter = m_faces.begin(); fiter != m_faces.end(); fiter ++  )
        {
                tFace f = *fiter;

                tHalfEdge he = faceHalfedge( f );

    do{
                        if( he->string().size() > 0 )
                          {
                                  _os << "Corner "<< he->vertex()->id() << " " << f->id() << " ";
                                  _os << "{" << he->string() << "}" << std::endl;
                          }
                          he = halfedgeNext( he );
                }while( he != f->halfedge() );

  }

        _os.close();
};


//assume the mesh is with uv coordinates and normal vector for each vertex
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::write_obj( const char * output )
{
        std::fstream _os( output, std::fstream::out );
        if( _os.fail() )
        {
                fprintf(stderr,"Error is opening file %s\n", output );
                return;
        }

        int vid = 1;
        for( std::list<CVertex*>::iterator viter = m_verts.begin(); viter != m_verts.end(); viter ++)
        {
                tVertex v = *viter;
                v->id() = vid ++;
        }

        for( std::list<CVertex*>::iterator viter = m_verts.begin(); viter != m_verts.end(); viter ++)
        {
                tVertex v = *viter;

                _os << "v";
                
                for( int i = 0; i < 3; i ++ )
                {
                        _os << " " << v->point()[i];
                }
                _os << std::endl;
        }

        for( std::list<CVertex*>::iterator viter = m_verts.begin(); viter != m_verts.end(); viter ++)
        {
                tVertex v = *viter;

                _os << "vt";
                
                for( int i = 0; i < 2; i ++ )
                {
                        _os << " " << v->uv()[i];
                }
                _os << std::endl;
        }

        for( std::list<CVertex*>::iterator viter = m_verts.begin(); viter != m_verts.end(); viter ++)
        {
                tVertex v = *viter;

                _os << "vn";
                
                for( int i = 0; i < 3; i ++ )
                {
                        _os << " " << v->normal()[i];
                }
                _os << std::endl;
        }


  for( std::list<CFace*>::iterator fiter = m_faces.begin(); fiter != m_faces.end(); fiter ++ )
        {
                tFace f = *fiter;

                _os << "f";

                tHalfEdge he = f->halfedge();
                
                do{
                        int vid = he->target()->id();
                        _os << " " <<  vid << "/" << vid << "/" << vid;
                        he = he->he_next();
                }while( he != f->halfedge() );
                _os << std::endl;
        }

        _os.close();
};

//template pointer converting to base class pointer is OK (BasePointer) = (TemplatePointer)
//(TemplatePointer)=(BasePointer) is incorrect
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::deleteFace( tFace  pFace )
{         
          std::map<int,tFace>::iterator fiter = m_map_face.find( pFace->id() );
          if( fiter != m_map_face.end() )
          {
                  m_map_face.erase( fiter );
          }     
          m_faces.remove( pFace );

                
         //create halfedges
         tHalfEdge hes[3];

         hes[0] = faceHalfedge( pFace );
         hes[1] = faceNextCcwHalfEdge( hes[0] );
         hes[2] = faceNextCcwHalfEdge( hes[1] );

         for(int i = 0; i < 3; i ++ )
         {
                //connection with edge
                CHalfEdge * pH = hes[i];

                //connection to target
                CVertex * pV = halfedgeTarget( pH );
                if( pV->halfedge() == pH )
                {
                        if( pH->he_next()->he_sym() != NULL )
                                pV->halfedge() = pH->he_next()->he_sym();
                        else
                        {
                                assert( pH->he_sym() != NULL ); //otherwise the mesh is not a manifold
                                pV->halfedge() = pH->he_sym()->he_prev();
                        }
                }
         }

                for(int i = 0; i < 3; i ++ )
                {
                        //connection with edge
                        CHalfEdge * pH = hes[i];
                        CHalfEdge * pS = halfedgeSym( pH );
                        CEdge * pE = halfedgeEdge( pH );

                        pE->halfedge(0) = pS;
                        pE->halfedge(1) = NULL;

                        if( pS == NULL )
                        {
                                //assert(0);
                                m_edges.remove( pE );
                                CVertex * v0 = halfedgeSource( pH );
                                CVertex * v1 = halfedgeTarget( pH );
                                CEdgeKey key(v0->id(),v1->id());
                                std::map<CEdgeKey,tEdge>::iterator eiter = m_map_edge.find(key);
                                if( eiter != m_map_edge.end() )
                                        m_map_edge.erase( eiter );
                                delete pE;
                        }

                        
                }
                
                //remove half edges
                for(int i = 0; i < 3; i ++ )
                {
                        delete hes[i];
                }
                
                delete pFace;
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>::read_off( const char * input )
{
        std::fstream is( input, std::fstream::in );

        if( is.fail() )
        {
                fprintf(stderr,"Error is opening file %s\n", input );
                return;
        }

        char buffer[MAX_LINE];

        //read in the first line "OFF"

        while( is.getline(buffer, MAX_LINE )  )
        {               
                std::string line( buffer );
        
                strutil::Tokenizer stokenizer( line, " \r\n" );

                stokenizer.nextToken();
                std::string token = stokenizer.getToken();
                if( token == "OFF"  ) break;
        }

        int nVertices, nFaces, nEdges;

        //read in Vertex Number, Face Number, Edge Number

                is.getline(buffer, MAX_LINE );
                std::string line( buffer );
        
                strutil::Tokenizer stokenizer( line, " \r\n" );

                stokenizer.nextToken();
                std::string token = stokenizer.getToken();
                nVertices = strutil::parseString<int>( token );

                stokenizer.nextToken();
                token = stokenizer.getToken();
                nFaces = strutil::parseString<int>( token );

                stokenizer.nextToken();
                token = stokenizer.getToken();
                nEdges = strutil::parseString<int>( token );

                //printf("V %d F %d E %d\n" , nVertices, nFaces, nEdges);
        

        for( int id = 0; id < nVertices; id ++ )
        {
                is.getline(buffer, MAX_LINE );
                std::string line( buffer );
                
                strutil::Tokenizer stokenizer( line, " \r\n" );
                CPoint p;
                for( int j = 0; j < 3; j ++ )
                {
                        stokenizer.nextToken();
                        std::string token = stokenizer.getToken();
                        p[j] = strutil::parseString<float>( token );
                }

                        CVertex * v = createVertex( id + 1 );
                        v->point() = p;
        }


        for( int id = 0; id < nFaces; id ++ )
        {

                is.getline(buffer, MAX_LINE );
                std::string line( buffer );
                
                strutil::Tokenizer stokenizer( line, " \r\n" );
                stokenizer.nextToken();
                std::string token = stokenizer.getToken();
                
                int n = strutil::parseString<int>(token);
                assert( n == 3 );

                CVertex * v[3];
                for( int j = 0; j < 3; j ++ )
                {
                        stokenizer.nextToken();
                        std::string token = stokenizer.getToken();
                        int vid = strutil::parseString<int>( token );
                        v[j] = idVertex( vid + 1);
                }
                
                createFace( v, id + 1 );
        }

        is.close();

        //Label boundary edges
        for(std::list<CEdge*>::iterator eiter= m_edges.begin() ; eiter != m_edges.end() ; ++ eiter )
        {
                CEdge *     edge = *eiter;
                CHalfEdge * he[2];

                he[0] = edge->halfedge(0);
                he[1] = edge->halfedge(1);
                
                assert( he[0] != NULL );
                

                if( he[1] != NULL )
                {
                        assert( he[0]->target() == he[1]->source() && he[0]->source() == he[1]->target() );

                        if( he[0]->target()->id() < he[0]->source()->id() )
                        {
                                edge->halfedge(0 ) = he[1];
                                edge->halfedge(1 ) = he[0];
                        }

                        assert( edgeVertex1(edge)->id() < edgeVertex2(edge)->id() );
                }
                else
                {
                        he[0]->vertex()->boundary() = true;
                        he[0]->he_prev()->vertex()->boundary()  = true;
                }

        }

        std::list<CVertex*> dangling_verts;
        //Label boundary edges
        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                tVertex     v = *viter;
                if( v->halfedge() != NULL ) continue;
                dangling_verts.push_back( v );
        }

        for( std::list<CVertex*>::iterator  viter = dangling_verts.begin() ; viter != dangling_verts.end(); ++ viter )
        {
                tVertex v = *viter;
                m_verts.remove( v );
                delete v;
                v = NULL;
        }

        //Arrange the boundary half_edge of boundary vertices, to make its halfedge
        //to be the most ccw in half_edge

        for(std::list<CVertex*>::iterator viter = m_verts.begin();  viter != m_verts.end() ; ++ viter )
        {
                tVertex     v = *viter;
                if( !v->boundary() ) continue;

                CHalfEdge * he = v->halfedge();
                while( he->he_sym() != NULL )
                {
                        he = he->ccw_rotate_about_target();
                }
                v->halfedge() = he;
        }


};




}//name space MeshLib

#endif //_MESHLIB_BASE_MESH_H_ defined