Subversion Repositories gelsvn

#include <iostream>

#include "Vertex.h"
#include "Manifold.h"
#include "VertexCirculator.h"

namespace HMesh
{
        using namespace std;
        using namespace CGLA;
        
        VertexIter get_null_vertex_iter()
        {
                static VertexList l;
                return l.end();
        }
        
        
        template<class R>
        Vertex_template<R>::Vertex_template(const CGLA::Vec3f& _pos): 
        he(NULL_HALFEDGE_ITER),
        pos(_pos),
        touched(0)
        {}
        
        bool is_boundary(VertexIter v)
        {
                return is_boundary(v->he);
        }
        
        void check_boundary_consistency(VertexIter v)
        {
                HalfEdgeIter h = v->he;
                HalfEdgeIter h0 = h;
                
                while(h->face != NULL_FACE_ITER)
                {
                        h = h->prev->opp;
                        if(h==h0) return;
                }
                
                v->he = h;
                HalfEdgeIter h_opp = h->opp;
                while(h_opp->face != NULL_FACE_ITER)
                        h_opp = h_opp->next->opp;
                h_opp->vert = v;
                link(h_opp,h);
        }
        
        int valency(VertexIter v) 
        {
                VertexCirculator vc(v);
                for(;!vc.end();++vc);
                return vc.no_steps();
        }
        
        const Vec3f normal(VertexIter v)
        {
                Vec3f p0 = v->pos;
                vector<Vec3f> one_ring;                                         
                for(VertexCirculator vc(v);!vc.end();++vc)
                {
                        Vec3f p = vc.get_vertex()->pos;
                        Vec3f edge = p-p0;
                        float len = length(edge);
                        if(len>0.0f)
                                one_ring.push_back(edge/len);
                }
                
                Vec3f norm(0);
                int N = one_ring.size();
                for(int i=0;i<N-1;++i)
                {
                        Vec3f e1 = one_ring[i];
                        Vec3f e0 = one_ring[(i+1)%N];
                        Vec3f n = normalize(cross(e0,e1));
                        norm += n*acos(max(-1.0f,min(1.0f,dot(e0,e1))));
                }
                float l = sqr_length(norm);
                if(l>0.0f)
                        return norm/sqrt(l);
                
                return norm;
        }
        
        bool is_connected(VertexIter v1, VertexIter v2)
        {
                vector<VertexIter> vertices;
                VertexCirculator vc(v1);
                for(;!vc.end();++vc)
                        vertices.push_back(vc.get_vertex());
                if(find(vertices.begin(),vertices.end(),v2) != vertices.end())
                        return true;
                return false;
        }
        
        template struct Vertex_template<Iters>; 
        
}