Subversion Repositories gelsvn

#include <iostream>

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

namespace HMesh
{

        using namespace std;
        using namespace CGLA;

        template<class R>
        Vertex_template<R>::Vertex_template(const CGLA::Vec3f& _pos): 
                he(NULL_HALFEDGE_ITER),
                pos(_pos),
                touched(0)
        {}


        template<class R>
        bool Vertex_template<R>::is_boundary()
        {
                return he->is_boundary();
        }

        template<class R>
        void Vertex_template<R>::check_boundary_consistency()
        {
                HalfEdgeIter h = he;
                HalfEdgeIter h0 = h;
#ifndef NDEBUG
                int k=0;
#endif
                while(h->face != NULL_FACE_ITER)
                        {
                                assert(h->prev != NULL_HALFEDGE_ITER);
                                assert(h->prev->opp != NULL_HALFEDGE_ITER);
#ifndef NDEBUG
                                if(++k == 1e6) 
                                        {
                                                cout << __FILE__ << __LINE__ 
                                                                 << " : Oops infinite loop around vertex" << endl;
                                                return;
                                        }
#endif
                                h = h->prev->opp;
                                if(h==h0) return;
                        }

                he = h;
                HalfEdgeIter h_opp = he->opp;
                while(h_opp->face != NULL_FACE_ITER)
                        h_opp = h_opp->next->opp;
                h_opp->next = h;
                h->prev = h_opp;
        }

        int valency(VertexIter v) 
        {
                VertexCirculator vc(v);
                for(;!vc.end();++vc);
                return vc.no_steps();
        }

        const Vec3f normal(VertexIter v)
        {
                Vec3f p0 = v->get_pos();
                vector<Vec3f> one_ring;                                         
                for(VertexCirculator vc(v);!vc.end();++vc)
                        {
                                Vec3f p = vc.get_vertex()->get_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;++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;
        }
        
        VertexIter NULL_VERTEX_ITER(0);
        
        template class Vertex_template<Iters>;
}