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)
                {}

                bool is_boundary(VertexIter v)
                {
                                return is_boundary(v->he);
                }

                void check_boundary_consistency(VertexIter v)
                {
                                HalfEdgeIter h = v->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;
                                }

                                v->he = h;
                                HalfEdgeIter h_opp = v->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->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;++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>; 

}