WebSVN – gelsvn – Diff – /branches/cpp11-devel/src/HMesh/Manifold.cpp

     bool Manifold::remove_vertex(VertexID vid)
+    {
         if(!in_use(vid))
             return false;
-        Walker w = Manifold::walker(vid);
         vector<FaceID> faces;
-        for(; !w.full_circle(); w = w.circulate_vertex_ccw())
+        int N = circulate_vertex_ccw(*this, vid, [&](FaceID f) {
-            faces.push_back(w.face());
+            faces.push_back(f);
+        });
-        for(size_t i=0;i<faces.size();++i)
+        for(size_t i=0;i<N;++i)
             remove_face(faces[i]);
         return true;
+    }
     size_t link_intersection(const Manifold& m, VertexID v0, VertexID v1, vector<VertexID>& lisect)
+    {
         // get the one-ring of v0
         vector<VertexID> link0;
-        for(Walker vj = m.walker(v0);
+        circulate_vertex_ccw(m, v0, [&](VertexID vn) {
-			!vj.full_circle(); vj = vj.circulate_vertex_ccw())
-            link0.push_back(vj.vertex());
+            link0.push_back(vn);
+        });
         // get the one-ring of v1
         vector<VertexID> link1;
-        for(Walker vj = m.walker(v1);
+        circulate_vertex_ccw(m, v1, [&](VertexID vn) {
-			!vj.full_circle(); vj = vj.circulate_vertex_ccw())
-            link1.push_back(vj.vertex());
+            link1.push_back(vn);
+        });
         // sort the vertices of the two rings
         sort(link0.begin(), link0.end());
         sort(link1.begin(), link1.end());
+                }
+            }
             if(v0b != v0a)
-            {
-                Walker hew = walker(v0b);
-                for(;!hew.full_circle(); hew = hew.circulate_vertex_ccw())
+                circulate_vertex_ccw(*this, v0b, [&](Walker hew) {
                     kernel.set_vert(hew.opp().halfedge(), v0a);
-            }
+                });
             if(v1b != v1a)
-            {
-                Walker hew = walker(v1b);
-                for(;!hew.full_circle(); hew = hew.circulate_vertex_ccw())
+                circulate_vertex_ccw(*this, v1b, [&](Walker hew) {
                     kernel.set_vert(hew.opp().halfedge(), v1a);
-            }
+                });
             if(v0a != v0b)
+            {
                 HalfEdgeID h1p = kernel.prev(h1);
                 HalfEdgeID h0n = kernel.next(h0);
         Walker j  = m.walker(v);
         return boundary(m, j.halfedge());
+    }
     int valency(const Manifold& m, VertexID v)
+    {
-        // perform full circulation to get valency
-        Walker vj = m.walker(v);
-        while(!vj.full_circle())
-            vj = vj.circulate_vertex_cw();
+        return circulate_vertex_ccw(m,v, [](Walker){});
-        return vj.no_steps();
+    }
     Manifold::Vec normal(const Manifold& m, VertexID v)
+    {
         Manifold::Vec p0 = m.pos(v);
         vector<Manifold::Vec> one_ring;
         // run through outgoing edges, and store them normalized
-        for(Walker vj = m.walker(v); !vj.full_circle(); vj = vj.circulate_vertex_ccw()){
+        int N = circulate_vertex_ccw(m, v, [&](VertexID vn) {
-            Manifold::Vec edge = m.pos(vj.vertex())-p0;
+            Manifold::Vec edge = m.pos(vn) - p0;
-            float l = length(edge);
+            double l = length(edge);
+            if(l > 0.0)
-            if(l > 0.0f) one_ring.push_back(edge/l);
+                one_ring.push_back(edge/l);
-        }
+        });
-        Manifold::Vec n(0);
-        size_t N = one_ring.size();
         if(N<2)
             return Manifold::Vec(0);
         size_t N_count = N;
         size_t N_start = 0;
         if(boundary(m, v))
             N_start = 1;
         // sum up the normals of each face surrounding the vertex
+        Manifold::Vec n(0);
         for(size_t i = N_start; i < N_count; ++i){
             Manifold::Vec e0 = one_ring[i];
             Manifold::Vec e1 = one_ring[(i+1) % N];
             Manifold::Vec n_part = normalize(cross(e0, e1));
         return n;
+    }
     bool connected(const Manifold& m, VertexID v0, VertexID v1)
+    {
-        for(Walker vj = m.walker(v0); !vj.full_circle(); vj = vj.circulate_vertex_cw()){
-            if(vj.vertex() == v1)
+        bool c=false;
-                return true;
+        circulate_vertex_ccw(m, v0, [&](VertexID v){ c |= (v==v1);});
-        }
-        return false;
+        return c;
+    }
     int no_edges(const Manifold& m, FaceID f)
+    {
-        // perform full circulation to get valency
-        Walker w = m.walker(f);
-        for(; !w.full_circle(); w = w.circulate_face_cw());
+        return circulate_face_ccw(m, f, [](Walker w){});
-        return w.no_steps();
+    }
     Manifold::Vec normal(const Manifold& m, FaceID f)
+    {
         vector<Manifold::Vec> v;
-        int k=0;
-        for(Walker  w = m.walker(f); !w.full_circle(); w = w.circulate_face_ccw(),++k)
+        int k= circulate_face_ccw(m, f, [&](VertexID vid) {
-            v.push_back(m.pos(w.vertex()));
+            v.push_back(m.pos(vid));
+        });
         Manifold::Vec norm(0);
         for(int i=0;i<k;++i)
+        {
             norm[0] += (v[i][1]-v[(i+1)%k][1])*(v[i][2]+v[(i+1)%k][2]);
             norm /= sqrt(l);
         return norm;
+    }
-    float area(const Manifold& m, FaceID fid)
+    double area(const Manifold& m, FaceID fid)
+    {
         // Get all projected vertices
         vector<Manifold::Vec> vertices;
-        Walker w = m.walker(fid);
-        for(; !w.full_circle(); w = w.circulate_face_ccw())
+        int N = circulate_face_ccw(m, fid, [&](VertexID vid) {
-            vertices.push_back(m.pos(w.vertex()));
+            vertices.push_back(m.pos(vid));
-        float area = 0;
+        });
-        size_t N = vertices.size();
+        double area = 0;
         Manifold::Vec norm = normal(m,fid);
         for(int i = 1; i < N-1; ++i)
             area += 0.5 * dot(norm,cross(vertices[i]-vertices[0], vertices[(i+1 )]-vertices[0]));
         return area;
+    }
     Manifold::Vec centre(const Manifold& m, FaceID f)
+    {
         Manifold::Vec c(0);
-        Walker w = m.walker(f);
-        for(; !w.full_circle(); w = w.circulate_face_ccw()) c += m.pos(w.vertex());
+        int n = circulate_face_ccw(m, f, [&](VertexID v) {c+=m.pos(v);});
-        c /= w.no_steps();
-        return c;
+        return c / n;
+    }
-    float perimeter(const Manifold& m, FaceID f)
+    double perimeter(const Manifold& m, FaceID f)
+    {
-        float p=0.0;
+        double l=0.0;
-        Walker w = m.walker(f);
-        for(; !w.full_circle(); w = w.circulate_face_cw()) p += length(m, w.halfedge());
+        circulate_face_ccw(m, f, [&](HalfEdgeID h) { l+= length(m, h);});
-        return p;
+        return l;
+    }
     bool boundary(const Manifold& m, HalfEdgeID h)
+    {
         Walker w = m.walker(h);
         return w.face() == InvalidFaceID || w.opp().face() == InvalidFaceID;
+    }
-    float length(const Manifold& m, HalfEdgeID h)
+    double length(const Manifold& m, HalfEdgeID h)
+    {
         Walker w = m.walker(h);
         return (m.pos(w.vertex()) - m.pos(w.opp().vertex())).length();
+    }
+}

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/src/HMesh/Manifold.cpp @ 662 – Rev 631 → 633