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


/* ----------------------------------------------------------------------- *
 * This file is part of GEL, http://www.imm.dtu.dk/GEL
 * Copyright (C) the authors and DTU Informatics
 * For license and list of authors, see ../../doc/intro.pdf
 * ----------------------------------------------------------------------- */
 
#include "cleanup.h"
 
#include "../CGLA/Vec3f.h"
#include "../CGLA/Vec3d.h"
#include "../Geometry/QEM.h"
#include "../Geometry/KDTree.h"
 
#include "Manifold.h"
 
namespace HMesh
{
    using namespace std;
    using namespace CGLA;
    using namespace Geometry;
    
    namespace
    {
        /// get the minimum angle between 3 vertices
        float min_angle(const Vec3d& v0, const Vec3d& v1, const Vec3d& v2)
        {
            Vec3d a = normalize(v1-v0);
            Vec3d b = normalize(v2-v1);
            Vec3d c = normalize(v0-v2);
            
            return min(dot(a, -c), min(dot(b, -a), dot(c, -b)));
        }
        
        /// need description
        float edge_error(const Manifold& m, HalfEdgeID h, const Vec3d& pa, const Vec3d& pb)
        {
            QEM q;
            Walker j = m.walker(h);
            
            FaceID f = j.face();
            if(f != InvalidFaceID)
                q += QEM(Vec3d(0), Vec3d(normal(m, f)));
            
            f = j.opp().face();
            if(f != InvalidFaceID)
                q += QEM(Vec3d(0), Vec3d(normal(m, f)));
            
            return q.error(pb - pa);
        }
        
        /// need description
        float vertex_error(const Manifold& m, VertexID v, const Vec3d& pb)
        {
            QEM q;
            Vec3d pa(m.pos(v));
            
            for(Walker vj = m.walker(v); !vj.full_circle(); vj = vj.circulate_vertex_cw()){
                FaceID f = vj.face();
                if(f != InvalidFaceID)
                    q += QEM(Vec3d(0), Vec3d(normal(m, f)));
            }
            return q.error(pb - pa);
        }
    }
    
    void remove_caps(Manifold& m, float thresh)
    {
        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){
            Vec3d p[3];
            HalfEdgeID he[3];
            VertexID vh[3];
            
            // store ids of vertices and halfedges and vertex positions of face
            size_t n = 0;
            for(Walker fj = m.walker(*f); !fj.full_circle(); fj = fj.circulate_face_cw(), ++n){
                vh[n] = fj.vertex();
                p[n] = Vec3d(m.pos(vh[n]));
                
                // original face circulator implementation returned next halfedge, jumper doesn't. Can this be optimized?
                he[n] = fj.halfedge();
            }
            assert(n == 3);
            
            // calculate the edge lengths of face
            bool is_collapsed = false;
            Vec3d edges[3];
            for(size_t i = 0; i < 3; ++i){
                edges[i] = p[(i+1)%3] - p[i];
                float l = length(edges[i]);
                if(l < 1e-20)
                    is_collapsed = true;
                else
                    edges[i] /= l;
                
            }
            // an edge length was close to 1e-20, thus collapsed
            if(is_collapsed)
                continue;
            
            for(size_t i = 0; i < 3; ++i){
                float ang = acos(max(-1.0, min(1.0, dot(-edges[(i+2)%3], edges[i]))));
                
                // flip long edge of current face if angle exceeds cap threshold and result is better than current cap
                if(ang > thresh){
                    size_t iplus1 = (i+1)%3;
                    Vec3d edge_dir = edges[iplus1];
                    
                    Walker j = m.walker(he[iplus1]);
                    Vec3d v0(m.pos(j.vertex()));
                    Vec3d v1(m.pos(j.next().vertex()));
                    Vec3d v2(m.pos(j.opp().vertex()));
                    Vec3d v3(m.pos(j.opp().next().vertex()));
                    
                    float m1 = min(min_angle(v0, v1, v2), min_angle(v0, v2, v3));
                    float m2 = min(min_angle(v0, v1, v3), min_angle(v1, v2, v3));
                    
                    if(m1 < m2){
						// If the "cap vertex" projected onto the long edge is better in the
						// sense that there is less geometric error after the flip, then we
						// use the projected vertex. In other words, we see if it pays to snap
						// to the edge.
						Vec3d pprj = edge_dir * dot(edge_dir, p[i]-p[iplus1])+p[iplus1];
                        if(edge_error(m, he[iplus1], pprj, Vec3d(m.pos(vh[i]))) > vertex_error(m, vh[i], pprj))
                            m.pos(vh[i]) = pprj;
                        // flip if legal
                        if(precond_flip_edge(m, he[iplus1]))
                            m.flip_edge(he[iplus1]);
                        break;
                    }
                }
            }
        }
        
    }
    
    void remove_needles(Manifold& m, float thresh)
    {
        bool did_work = false;
        
        // remove needles until no more can be removed
        do{
            did_work = false;
            for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v){
                // don't attempt to remove needles if vertex is boundary
                if(boundary(m, *v))
                    continue;
                
                for(Walker vj = m.walker(*v); !vj.full_circle(); vj = vj.circulate_vertex_cw()){
                    // don't attempt to remove needles if vertex of jumper halfedge is boundary
                    //                 if(boundary(m, vj.vertex()))
                    //                        continue;
                    
                    HalfEdgeID h = vj.opp().halfedge();
                    //                    VertexID n = vj.vertex();
                    float dist = length(m, h);
                    
                    // collapse edge if allowed and needle is present
                    if(dist < thresh && precond_collapse_edge(m, h)){
                        //                        if(vertex_error(m, *v, Vec3d(m.pos(n))) < vertex_error(m, n, Vec3d(m.pos(*v))))
                        //                            m.pos(*v) = m.pos(n);
                        m.collapse_edge(h);
                        did_work = true;
                        break;
                    }
                }
            }
        }
        while(did_work);
    }
    
    int stitch_mesh(Manifold& m, double rad)
    {
        KDTree<Vec3d, VertexID> vtree;
        
        for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)
            if(boundary(m, *vid))
                vtree.insert(m.pos(*vid), *vid);
        vtree.build();
        
        VertexAttributeVector<int> cluster_id(m.allocated_vertices(),-1);
        vector<vector<HalfEdgeID> > clustered_halfedges;
        
        int cluster_ctr=0;
        for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)
            if(boundary(m, *vid) && cluster_id[*vid] == -1)
            {
                vector<Vec3d> keys;
                vector<VertexID> vals;
                int n = vtree.in_sphere(m.pos(*vid), rad, keys, vals);
                
                vector<HalfEdgeID> boundary_edges;
                for(int i=0;i<n;++i)
                {
                    cluster_id[vals[i]] = cluster_ctr;
                    Walker w = m.walker(vals[i]);
                    boundary_edges.push_back(w.halfedge());
                }
                clustered_halfedges.push_back(boundary_edges);
                ++cluster_ctr;
            }
        
        int unstitched=0;
        for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)
        {
            HalfEdgeID h0 = *hid;
            Walker w = m.walker(h0);
            if(w.face() == InvalidFaceID)
            {
                VertexID v0 = w.opp().vertex();
                VertexID v1 = w.vertex();
                
                int cid = cluster_id[v1];
                vector<HalfEdgeID>& stitch_candidates = clustered_halfedges[cid];
                size_t i=0;
                for(;i<stitch_candidates.size(); ++i)
                {
                    HalfEdgeID h1 = stitch_candidates[i];
                    if(m.in_use(h1))
                    {
                        Walker w = m.walker(h1);
                        if(cluster_id[w.vertex()] == cluster_id[v0])
                            if(m.stitch_boundary_edges(h0,h1))
                                break;
                    }
                    
                }
                if(i == stitch_candidates.size())
                    ++unstitched;
            }
        }
        return unstitched;    
    }
    
    void remove_valence_two_vertices(Manifold & m)
    {
        for(VertexID v: m.vertices())
            if(valency(m,v)==2)
            {
                Walker w = m.walker(v);
                if(precond_collapse_edge(m, w.halfedge()))
                    m.collapse_edge(w.halfedge());
            }
    }
    
    
    void stitch_more(Manifold& mani, double rad)
    {
        int unstitched, iter;
        for(iter=0;iter<2;++iter)
        {
            unstitched = stitch_mesh(mani, rad);
            if(unstitched == 0)
                break;
            
            vector<HalfEdgeID> hvec;
            for(HalfEdgeIDIterator h = mani.halfedges_begin(); h != mani.halfedges_end();++h)
                if(mani.walker(*h).face() == InvalidFaceID)
                    hvec.push_back(*h);
            for(size_t i=0;i<hvec.size(); ++i)
                mani.split_edge(hvec[i]);
            
        }
    }
    
    
    void close_holes(Manifold& m)
    {
        for(HalfEdgeIDIterator h =  m.halfedges_begin(); h != m.halfedges_end(); ++h){
            m.close_hole(*h);
        }
    }
    
    void flip_orientation(Manifold& m)
    {
        vector<Vec3d> vertices;
        VertexAttributeVector<int> idvec;
        int k=0;
        for(VertexID v: m.vertices()) {
            idvec[v] = k++;
            vertices.push_back(m.pos(v));
        }
        vector<int> indices;
        vector<int> faces;
        for(FaceID f: m.faces()) {
            faces.push_back(no_edges(m, f));
            circulate_face_cw(m, f, [&](VertexID v){
                indices.push_back(idvec[v]);
            });
        }
        m.clear();
        m.build(vertices.size(), vertices[0].get(), faces.size(), &faces[0], &indices[0]);
    }
    
}
 
Generated by GNU Enscript 1.6.6.
 
 
 

Rev 630	Rev 666
1	`/* ----------------------------------------------------------------------- *`	1	`/* ----------------------------------------------------------------------- *`
2	`* This file is part of GEL, http://www.imm.dtu.dk/GEL`	2	`* This file is part of GEL, http://www.imm.dtu.dk/GEL`
3	`* Copyright (C) the authors and DTU Informatics`	3	`* Copyright (C) the authors and DTU Informatics`
4	`* For license and list of authors, see ../../doc/intro.pdf`	4	`* For license and list of authors, see ../../doc/intro.pdf`
5	`* ----------------------------------------------------------------------- */`	5	`* ----------------------------------------------------------------------- */`
6		6
7	`#include "cleanup.h"`	7	`#include "cleanup.h"`
8		8
9	`#include "../CGLA/Vec3f.h"`	9	`#include "../CGLA/Vec3f.h"`
10	`#include "../CGLA/Vec3d.h"`	10	`#include "../CGLA/Vec3d.h"`
11	`#include "../Geometry/QEM.h"`	11	`#include "../Geometry/QEM.h"`
12	`#include "../Geometry/KDTree.h"`	12	`#include "../Geometry/KDTree.h"`
13		13
14	`#include "Manifold.h"`	14	`#include "Manifold.h"`
15		15
16	`namespace HMesh`	16	`namespace HMesh`
17	`{`	17	`{`
18	`using namespace std;`	18	`using namespace std;`
19	`using namespace CGLA;`	19	`using namespace CGLA;`
20	`using namespace Geometry;`	20	`using namespace Geometry;`
21		21
22	`namespace`	22	`namespace`
23	`{`	23	`{`
24	`/// get the minimum angle between 3 vertices`	24	`/// get the minimum angle between 3 vertices`
25	`float min_angle(const Vec3d& v0, const Vec3d& v1, const Vec3d& v2)`	25	`float min_angle(const Vec3d& v0, const Vec3d& v1, const Vec3d& v2)`
26	`{`	26	`{`
27	`Vec3d a = normalize(v1-v0);`	27	`Vec3d a = normalize(v1-v0);`
28	`Vec3d b = normalize(v2-v1);`	28	`Vec3d b = normalize(v2-v1);`
29	`Vec3d c = normalize(v0-v2);`	29	`Vec3d c = normalize(v0-v2);`
30		30
31	`return min(dot(a, -c), min(dot(b, -a), dot(c, -b)));`	31	`return min(dot(a, -c), min(dot(b, -a), dot(c, -b)));`
32	`}`	32	`}`
33		33
34	`/// need description`	34	`/// need description`
35	`float edge_error(const Manifold& m, HalfEdgeID h, const Vec3d& pa, const Vec3d& pb)`	35	`float edge_error(const Manifold& m, HalfEdgeID h, const Vec3d& pa, const Vec3d& pb)`
36	`{`	36	`{`
37	`QEM q;`	37	`QEM q;`
38	`Walker j = m.walker(h);`	38	`Walker j = m.walker(h);`
39		39
40	`FaceID f = j.face();`	40	`FaceID f = j.face();`
41	`if(f != InvalidFaceID)`	41	`if(f != InvalidFaceID)`
42	`q += QEM(Vec3d(0), Vec3d(normal(m, f)));`	42	`q += QEM(Vec3d(0), Vec3d(normal(m, f)));`
43		43
44	`f = j.opp().face();`	44	`f = j.opp().face();`
45	`if(f != InvalidFaceID)`	45	`if(f != InvalidFaceID)`
46	`q += QEM(Vec3d(0), Vec3d(normal(m, f)));`	46	`q += QEM(Vec3d(0), Vec3d(normal(m, f)));`
47		47
48	`return q.error(pb - pa);`	48	`return q.error(pb - pa);`
49	`}`	49	`}`
50		50
51	`/// need description`	51	`/// need description`
52	`float vertex_error(const Manifold& m, VertexID v, const Vec3d& pb)`	52	`float vertex_error(const Manifold& m, VertexID v, const Vec3d& pb)`
53	`{`	53	`{`
54	`QEM q;`	54	`QEM q;`
55	`Vec3d pa(m.pos(v));`	55	`Vec3d pa(m.pos(v));`
56		56
57	`for(Walker vj = m.walker(v); !vj.full_circle(); vj = vj.circulate_vertex_cw()){`	57	`for(Walker vj = m.walker(v); !vj.full_circle(); vj = vj.circulate_vertex_cw()){`
58	`FaceID f = vj.face();`	58	`FaceID f = vj.face();`
59	`if(f != InvalidFaceID)`	59	`if(f != InvalidFaceID)`
60	`q += QEM(Vec3d(0), Vec3d(normal(m, f)));`	60	`q += QEM(Vec3d(0), Vec3d(normal(m, f)));`
61	`}`	61	`}`
62	`return q.error(pb - pa);`	62	`return q.error(pb - pa);`
63	`}`	63	`}`
64	`}`	64	`}`
65		65
66	`void remove_caps(Manifold& m, float thresh)`	66	`void remove_caps(Manifold& m, float thresh)`
67	`{`	67	`{`
68	`for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){`	68	`for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){`
69	`Vec3d p[3];`	69	`Vec3d p[3];`
70	`HalfEdgeID he[3];`	70	`HalfEdgeID he[3];`
71	`VertexID vh[3];`	71	`VertexID vh[3];`
72		72
73	`// store ids of vertices and halfedges and vertex positions of face`	73	`// store ids of vertices and halfedges and vertex positions of face`
74	`size_t n = 0;`	74	`size_t n = 0;`
75	`for(Walker fj = m.walker(*f); !fj.full_circle(); fj = fj.circulate_face_cw(), ++n){`	75	`for(Walker fj = m.walker(*f); !fj.full_circle(); fj = fj.circulate_face_cw(), ++n){`
76	`vh[n] = fj.vertex();`	76	`vh[n] = fj.vertex();`
77	`p[n] = Vec3d(m.pos(vh[n]));`	77	`p[n] = Vec3d(m.pos(vh[n]));`
78		78
79	`// original face circulator implementation returned next halfedge, jumper doesn't. Can this be optimized?`	79	`// original face circulator implementation returned next halfedge, jumper doesn't. Can this be optimized?`
80	`he[n] = fj.halfedge();`	80	`he[n] = fj.halfedge();`
81	`}`	81	`}`
82	`assert(n == 3);`	82	`assert(n == 3);`
83		83
84	`// calculate the edge lengths of face`	84	`// calculate the edge lengths of face`
85	`bool is_collapsed = false;`	85	`bool is_collapsed = false;`
86	`Vec3d edges[3];`	86	`Vec3d edges[3];`
87	`for(size_t i = 0; i < 3; ++i){`	87	`for(size_t i = 0; i < 3; ++i){`
88	`edges[i] = p[(i+1)%3] - p[i];`	88	`edges[i] = p[(i+1)%3] - p[i];`
89	`float l = length(edges[i]);`	89	`float l = length(edges[i]);`
90	`if(l < 1e-20)`	90	`if(l < 1e-20)`
91	`is_collapsed = true;`	91	`is_collapsed = true;`
92	`else`	92	`else`
93	`edges[i] /= l;`	93	`edges[i] /= l;`
94		94
95	`}`	95	`}`
96	`// an edge length was close to 1e-20, thus collapsed`	96	`// an edge length was close to 1e-20, thus collapsed`
97	`if(is_collapsed)`	97	`if(is_collapsed)`
98	`continue;`	98	`continue;`
99		99
100	`for(size_t i = 0; i < 3; ++i){`	100	`for(size_t i = 0; i < 3; ++i){`
101	`float ang = acos(max(-1.0, min(1.0, dot(-edges[(i+2)%3], edges[i]))));`	101	`float ang = acos(max(-1.0, min(1.0, dot(-edges[(i+2)%3], edges[i]))));`
102		102
103	`// flip long edge of current face if angle exceeds cap threshold and result is better than current cap`	103	`// flip long edge of current face if angle exceeds cap threshold and result is better than current cap`
104	`if(ang > thresh){`	104	`if(ang > thresh){`
105	`size_t iplus1 = (i+1)%3;`	105	`size_t iplus1 = (i+1)%3;`
106	`Vec3d edge_dir = edges[iplus1];`	106	`Vec3d edge_dir = edges[iplus1];`
107		107
108	`Walker j = m.walker(he[iplus1]);`	108	`Walker j = m.walker(he[iplus1]);`
109	`Vec3d v0(m.pos(j.vertex()));`	109	`Vec3d v0(m.pos(j.vertex()));`
110	`Vec3d v1(m.pos(j.next().vertex()));`	110	`Vec3d v1(m.pos(j.next().vertex()));`
111	`Vec3d v2(m.pos(j.opp().vertex()));`	111	`Vec3d v2(m.pos(j.opp().vertex()));`
112	`Vec3d v3(m.pos(j.opp().next().vertex()));`	112	`Vec3d v3(m.pos(j.opp().next().vertex()));`
113		113
114	`float m1 = min(min_angle(v0, v1, v2), min_angle(v0, v2, v3));`	114	`float m1 = min(min_angle(v0, v1, v2), min_angle(v0, v2, v3));`
115	`float m2 = min(min_angle(v0, v1, v3), min_angle(v1, v2, v3));`	115	`float m2 = min(min_angle(v0, v1, v3), min_angle(v1, v2, v3));`
116		116
117	`if(m1 < m2){`	117	`if(m1 < m2){`
118	`// If the "cap vertex" projected onto the long edge is better in the`	118	`// If the "cap vertex" projected onto the long edge is better in the`
119	`// sense that there is less geometric error after the flip, then we`	119	`// sense that there is less geometric error after the flip, then we`
120	`// use the projected vertex. In other words, we see if it pays to snap`	120	`// use the projected vertex. In other words, we see if it pays to snap`
121	`// to the edge.`	121	`// to the edge.`
122	`Vec3d pprj = edge_dir * dot(edge_dir, p[i]-p[iplus1])+p[iplus1];`	122	`Vec3d pprj = edge_dir * dot(edge_dir, p[i]-p[iplus1])+p[iplus1];`
123	`if(edge_error(m, he[iplus1], pprj, Vec3d(m.pos(vh[i]))) > vertex_error(m, vh[i], pprj))`	123	`if(edge_error(m, he[iplus1], pprj, Vec3d(m.pos(vh[i]))) > vertex_error(m, vh[i], pprj))`
124	`m.pos(vh[i]) = pprj;`	124	`m.pos(vh[i]) = pprj;`
125	`// flip if legal`	125	`// flip if legal`
126	`if(precond_flip_edge(m, he[iplus1]))`	126	`if(precond_flip_edge(m, he[iplus1]))`
127	`m.flip_edge(he[iplus1]);`	127	`m.flip_edge(he[iplus1]);`
128	`break;`	128	`break;`
129	`}`	129	`}`
130	`}`	130	`}`
131	`}`	131	`}`
132	`}`	132	`}`
133		133
134	`}`	134	`}`
135		135
136	`void remove_needles(Manifold& m, float thresh)`	136	`void remove_needles(Manifold& m, float thresh)`
137	`{`	137	`{`
138	`bool did_work = false;`	138	`bool did_work = false;`
139		139
140	`// remove needles until no more can be removed`	140	`// remove needles until no more can be removed`
141	`do{`	141	`do{`
142	`did_work = false;`	142	`did_work = false;`
143	`for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v){`	143	`for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v){`
144	`// don't attempt to remove needles if vertex is boundary`	144	`// don't attempt to remove needles if vertex is boundary`
145	`if(boundary(m, *v))`	145	`if(boundary(m, *v))`
146	`continue;`	146	`continue;`
147		147
148	`for(Walker vj = m.walker(*v); !vj.full_circle(); vj = vj.circulate_vertex_cw()){`	148	`for(Walker vj = m.walker(*v); !vj.full_circle(); vj = vj.circulate_vertex_cw()){`
149	`// don't attempt to remove needles if vertex of jumper halfedge is boundary`	149	`// don't attempt to remove needles if vertex of jumper halfedge is boundary`
150	`// if(boundary(m, vj.vertex()))`	150	`// if(boundary(m, vj.vertex()))`
151	`// continue;`	151	`// continue;`
152		152
153	`HalfEdgeID h = vj.opp().halfedge();`	153	`HalfEdgeID h = vj.opp().halfedge();`
154	`// VertexID n = vj.vertex();`	154	`// VertexID n = vj.vertex();`
155	`float dist = length(m, h);`	155	`float dist = length(m, h);`
156		156
157	`// collapse edge if allowed and needle is present`	157	`// collapse edge if allowed and needle is present`
158	`if(dist < thresh && precond_collapse_edge(m, h)){`	158	`if(dist < thresh && precond_collapse_edge(m, h)){`
159	`// if(vertex_error(m, v, Vec3d(m.pos(n))) < vertex_error(m, n, Vec3d(m.pos(v))))`	159	`// if(vertex_error(m, v, Vec3d(m.pos(n))) < vertex_error(m, n, Vec3d(m.pos(v))))`
160	`// m.pos(*v) = m.pos(n);`	160	`// m.pos(*v) = m.pos(n);`
161	`m.collapse_edge(h);`	161	`m.collapse_edge(h);`
162	`did_work = true;`	162	`did_work = true;`
163	`break;`	163	`break;`
164	`}`	164	`}`
165	`}`	165	`}`
166	`}`	166	`}`
167	`}`	167	`}`
168	`while(did_work);`	168	`while(did_work);`
169	`}`	169	`}`
170		170
171	`int stitch_mesh(Manifold& m)`	171	`int stitch_mesh(Manifold& m, double rad)`
172	`{`	172	`{`
173	`KDTree<Vec3d, VertexID> vtree;`	173	`KDTree<Vec3d, VertexID> vtree;`
174		174
175	`for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)`	175	`for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)`
176	`if(boundary(m, *vid))`	176	`if(boundary(m, *vid))`
177	`vtree.insert(m.pos(vid), vid);`	177	`vtree.insert(m.pos(vid), vid);`
178	`vtree.build();`	178	`vtree.build();`
179		179
180	`VertexAttributeVector<int> cluster_id(m.allocated_vertices(),-1);`	180	`VertexAttributeVector<int> cluster_id(m.allocated_vertices(),-1);`
181	`vector<vector<HalfEdgeID> > clustered_halfedges;`	181	`vector<vector<HalfEdgeID> > clustered_halfedges;`
182		182
183	`int cluster_ctr=0;`	183	`int cluster_ctr=0;`
184	`for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)`	184	`for(VertexIDIterator vid = m.vertices_begin(); vid != m.vertices_end(); ++vid)`
185	`if(boundary(m, vid) && cluster_id[vid] == -1)`	185	`if(boundary(m, vid) && cluster_id[vid] == -1)`
186	`{`	186	`{`
187	`vector<Vec3d> keys;`	187	`vector<Vec3d> keys;`
188	`vector<VertexID> vals;`	188	`vector<VertexID> vals;`
189	`int n = vtree.in_sphere(m.pos(*vid), 1e-5, keys, vals);`	189	`int n = vtree.in_sphere(m.pos(*vid), rad, keys, vals);`
190		190
191	`vector<HalfEdgeID> boundary_edges;`	191	`vector<HalfEdgeID> boundary_edges;`
192	`for(int i=0;i<n;++i)`	192	`for(int i=0;i<n;++i)`
193	`{`	193	`{`
194	`cluster_id[vals[i]] = cluster_ctr;`	194	`cluster_id[vals[i]] = cluster_ctr;`
195	`Walker w = m.walker(vals[i]);`	195	`Walker w = m.walker(vals[i]);`
196	`boundary_edges.push_back(w.halfedge());`	196	`boundary_edges.push_back(w.halfedge());`
197	`}`	197	`}`
198	`clustered_halfedges.push_back(boundary_edges);`	198	`clustered_halfedges.push_back(boundary_edges);`
199	`++cluster_ctr;`	199	`++cluster_ctr;`
200	`}`	200	`}`
201		201
202	`int unstitched=0;`	202	`int unstitched=0;`
203	`for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)`	203	`for(HalfEdgeIDIterator hid = m.halfedges_begin(); hid != m.halfedges_end(); ++hid)`
204	`{`	204	`{`
205	`HalfEdgeID h0 = *hid;`	205	`HalfEdgeID h0 = *hid;`
206	`Walker w = m.walker(h0);`	206	`Walker w = m.walker(h0);`
207	`if(w.face() == InvalidFaceID)`	207	`if(w.face() == InvalidFaceID)`
208	`{`	208	`{`
209	`VertexID v0 = w.opp().vertex();`	209	`VertexID v0 = w.opp().vertex();`
210	`VertexID v1 = w.vertex();`	210	`VertexID v1 = w.vertex();`
211		211
212	`int cid = cluster_id[v1];`	212	`int cid = cluster_id[v1];`
213	`vector<HalfEdgeID>& stitch_candidates = clustered_halfedges[cid];`	213	`vector<HalfEdgeID>& stitch_candidates = clustered_halfedges[cid];`
214	`size_t i=0;`	214	`size_t i=0;`
215	`for(;i<stitch_candidates.size(); ++i)`	215	`for(;i<stitch_candidates.size(); ++i)`
216	`{`	216	`{`
217	`HalfEdgeID h1 = stitch_candidates[i];`	217	`HalfEdgeID h1 = stitch_candidates[i];`
218	`if(m.in_use(h1))`	218	`if(m.in_use(h1))`
219	`{`	219	`{`
220	`Walker w = m.walker(h1);`	220	`Walker w = m.walker(h1);`
221	`if(cluster_id[w.vertex()] == cluster_id[v0])`	221	`if(cluster_id[w.vertex()] == cluster_id[v0])`
222	`if(m.stitch_boundary_edges(h0,h1))`	222	`if(m.stitch_boundary_edges(h0,h1))`
223	`break;`	223	`break;`
224	`}`	224	`}`
225		225
226	`}`	226	`}`
227	`if(i == stitch_candidates.size())`	227	`if(i == stitch_candidates.size())`
228	`++unstitched;`	228	`++unstitched;`
229	`}`	229	`}`
230	`}`	230	`}`
231	`return unstitched;`	231	`return unstitched;`
232	`}`	232	`}`
233		233
-		234	`void remove_valence_two_vertices(Manifold & m)`
-		235	`{`
-		236	`for(VertexID v: m.vertices())`
-		237	`if(valency(m,v)==2)`
-		238	`{`
-		239	`Walker w = m.walker(v);`
-		240	`if(precond_collapse_edge(m, w.halfedge()))`
-		241	`m.collapse_edge(w.halfedge());`
-		242	`}`
-		243	`}`
-		244
234		245
235	`void stitch_more(Manifold& mani)`	246	`void stitch_more(Manifold& mani, double rad)`
236	`{`	247	`{`
237	`int unstitched, iter;`	248	`int unstitched, iter;`
238	`for(iter=0;iter<2;++iter)`	249	`for(iter=0;iter<2;++iter)`
239	`{`	250	`{`
240	`unstitched = stitch_mesh(mani);`	251	`unstitched = stitch_mesh(mani, rad);`
241	`if(unstitched == 0)`	252	`if(unstitched == 0)`
242	`break;`	253	`break;`
243		254
244	`vector<HalfEdgeID> hvec;`	255	`vector<HalfEdgeID> hvec;`
245	`for(HalfEdgeIDIterator h = mani.halfedges_begin(); h != mani.halfedges_end();++h)`	256	`for(HalfEdgeIDIterator h = mani.halfedges_begin(); h != mani.halfedges_end();++h)`
246	`if(mani.walker(*h).face() == InvalidFaceID)`	257	`if(mani.walker(*h).face() == InvalidFaceID)`
247	`hvec.push_back(*h);`	258	`hvec.push_back(*h);`
248	`for(size_t i=0;i<hvec.size(); ++i)`	259	`for(size_t i=0;i<hvec.size(); ++i)`
249	`mani.split_edge(hvec[i]);`	260	`mani.split_edge(hvec[i]);`
250		261
251	`}`	262	`}`
252	`}`	263	`}`
253		264
254		265
255	`void close_holes(Manifold& m)`	266	`void close_holes(Manifold& m)`
256	`{`	267	`{`
257	`for(HalfEdgeIDIterator h = m.halfedges_begin(); h != m.halfedges_end(); ++h){`	268	`for(HalfEdgeIDIterator h = m.halfedges_begin(); h != m.halfedges_end(); ++h){`
258	`m.close_hole(*h);`	269	`m.close_hole(*h);`
259	`}`	270	`}`
260	`}`	271	`}`
-		272
-		273	`void flip_orientation(Manifold& m)`
-		274	`{`
-		275	`vector<Vec3d> vertices;`
-		276	`VertexAttributeVector<int> idvec;`
-		277	`int k=0;`
-		278	`for(VertexID v: m.vertices()) {`
-		279	`idvec[v] = k++;`
-		280	`vertices.push_back(m.pos(v));`
-		281	`}`
-		282	`vector<int> indices;`
-		283	`vector<int> faces;`
-		284	`for(FaceID f: m.faces()) {`
-		285	`faces.push_back(no_edges(m, f));`
-		286	`circulate_face_cw(m, f, [&](VertexID v){`
-		287	`indices.push_back(idvec[v]);`
-		288	`});`
-		289	`}`
-		290	`m.clear();`
-		291	`m.build(vertices.size(), vertices[0].get(), faces.size(), &faces[0], &indices[0]);`
-		292	`}`
261		293
262	`}`	294	`}`
263		295
264	`Generated by GNU Enscript 1.6.6.`	296	`Generated by GNU Enscript 1.6.6.`
265		297
266		298
267		299

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/src/HMesh/cleanup.cpp – Rev 630 → 666