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



    
    FaceID Manifold::add_face(std::vector<Manifold::Vec> points)
    {
        int F = points.size();
        vector<int> indices;
        for(size_t i=0;i<points.size(); ++i)
            indices.push_back(i);
        FaceID fid = *faces_end();
        build(points.size(), reinterpret_cast<double*>(&points[0]), 1, &F, &indices[0]);
        return fid;
    }

        }
        while(he != last);
        
        vector<HalfEdgeID> halfedges_garbage;
        vector<VertexID> vertices_garbage;
        for(size_t i=0;i<halfedges.size(); ++i)
        {
            HalfEdgeID h = halfedges[i];
            HalfEdgeID hopp = kernel.opp(h);
            if(kernel.face(hopp) == InvalidFaceID)
            {

                    kernel.set_out(v1, kernel.opp(kernel.prev(hopp)));
                }
                
            }
        }
        for(size_t i=0;i<halfedges_garbage.size();++i){
            kernel.remove_halfedge(kernel.opp(halfedges_garbage[i]));
            kernel.remove_halfedge(halfedges_garbage[i]);
        }
        for(size_t i=0;i<vertices_garbage.size(); ++i)
            kernel.remove_vertex(vertices_garbage[i]);
        
        kernel.remove_face(fid);
        return true;
    }

        vector<FaceID> faces;
        
        for(; !w.full_circle(); w = w.circulate_vertex_ccw())
            faces.push_back(w.face());
        
        for(size_t i=0;i<faces.size();++i)
            remove_face(faces[i]);
            
        return true;
    }
 

        int did_work;
        do
        {
            did_work = 0;
            vector<HalfEdgeID> loop_tmp(0);
            for(size_t i=0;i<loop.size();++i)
                if(walker(loop[i]).opp().halfedge() == loop[(i+1)%loop.size()])
                {
                    VertexID vid = walker(loop[i]).vertex();
                    if(vid != v)
                        garbage_vertices.push_back(walker(loop[i]).vertex());

                    loop[i] = InvalidHalfEdgeID;
                    loop[(i+1)%loop.size()] = InvalidHalfEdgeID;
                    ++did_work;
                    ++i;
                }
            for(size_t i=0;i<loop.size();++i)
                if(loop[i] != InvalidHalfEdgeID)
                    loop_tmp.push_back(loop[i]);
            loop = loop_tmp;
        } while(did_work > 0 && loop.size() > 4);
        
        // Check whether the loop is too long
        float loop_len=0.0;
        for(size_t i=0;i<loop.size();++i)
            loop_len += length(*this, loop[i]);
        if(loop_len > max_loop_length)
            return InvalidFaceID;
        
        // The following block checks wheteher the same halfedge appears twice. In this

        vector<HalfEdgeID>::iterator end_iter = unique(loop_tmp.begin(), loop_tmp.end());
        if(end_iter != loop_tmp.end())
            return InvalidFaceID;
        
        // Remove all faces and connected halfedges and the original vertex v.
        for(size_t i=0;i<garbage_vertices.size(); ++i)
            kernel.remove_vertex(garbage_vertices[i]);
        for(size_t i=0;i<garbage_faces.size(); ++i)
            kernel.remove_face(garbage_faces[i]);
        for(size_t i=0;i<garbage_halfedges.size(); ++i)
            kernel.remove_halfedge(garbage_halfedges[i]);
        if(!vertex_is_boundary)
            kernel.remove_vertex(v);
        
        // Create a new face for the merged one ring and link up all the halfedges
        // in the loop
        FaceID f = kernel.add_face();
        kernel.set_last(f,loop[0]);
        for(size_t i=0;i<loop.size(); ++i)
        {
            kernel.set_face(loop[i], f);
            Walker hw = walker(loop[i]);
            kernel.set_out(hw.vertex(),hw.opp().halfedge());
            link(loop[i],loop[(i+1)%loop.size()]);
            assert(hw.vertex() == walker(loop[(i+1)%loop.size()]).opp().vertex());
        }
        
        // Finally, we ensure boundary consitency for all vertices in the loop.
        for(size_t i=0;i<loop.size(); ++i)
        {
            Walker hw = walker(loop[i]);
            ensure_boundary_consistency(hw.vertex());
        }
        

                                  const int_type* indices)
    {
        vector<VertexID> vids(no_vertices);
        
        // create vertices corresponding to positions stored in vertvec
        for(size_t i=0;i<no_vertices;++i)
        {
            const float_type* v0 = &vertvec[i*3];
            pos(vids[i] = kernel.add_vertex()) = Manifold::Vec(v0[0], v0[1], v0[2]);
        }
        

        
        // We now create N pairs of edges, glue each pair and let them point to the appropriate
        // vertices.
        vector<HalfEdgeID> new_halfedges(N);
        vector<HalfEdgeID> new_halfedges_opp(N);
        for(size_t i=0;i<N; ++i)
        {
            new_halfedges[i] = kernel.add_halfedge();
            new_halfedges_opp[i] = kernel.add_halfedge();
            glue(new_halfedges[i], new_halfedges_opp[i]);
            kernel.set_vert(new_halfedges[i], pairs[i].second);

        HalfEdgeID h0p = kernel.last(f0);
        HalfEdgeID h1n = kernel.last(f1);
        
        // loop over all connections and link the new halfedges with the old
        // ones.
        for(size_t i=0;i<N; ++i)
        {
            while(kernel.vert(h0p) != pairs[i].first)
                h0p = kernel.next(h0p);
            while(kernel.vert(kernel.prev(h1n)) != pairs[i].second)
                h1n = kernel.prev(h1n);

            h0p = new_halfedges_opp[i];
            h1n = new_halfedges_opp[i];
        }
        
        // Create the faces and their connections
        for(size_t i=0;i<N; ++i)
        {
            HalfEdgeID last = new_halfedges[i];
            FaceID f = kernel.add_face();
            kernel.set_last(f, last);
            HalfEdgeID h = last;

Rev 601	Rev 605
Line 101...	Line 101...
101		101
102	`FaceID Manifold::add_face(std::vector<Manifold::Vec> points)`	102	`FaceID Manifold::add_face(std::vector<Manifold::Vec> points)`
103	`{`	103	`{`
104	`int F = points.size();`	104	`int F = points.size();`
105	`vector<int> indices;`	105	`vector<int> indices;`
106	`for(int i=0;i<points.size(); ++i)`	106	`for(size_t i=0;i<points.size(); ++i)`
107	`indices.push_back(i);`	107	`indices.push_back(i);`
108	`FaceID fid = *faces_end();`	108	`FaceID fid = *faces_end();`
109	`build(points.size(), reinterpret_cast<double*>(&points[0]), 1, &F, &indices[0]);`	109	`build(points.size(), reinterpret_cast<double*>(&points[0]), 1, &F, &indices[0]);`
110	`return fid;`	110	`return fid;`
111	`}`	111	`}`
Line 127...	Line 127...
127	`}`	127	`}`
128	`while(he != last);`	128	`while(he != last);`
129		129
130	`vector<HalfEdgeID> halfedges_garbage;`	130	`vector<HalfEdgeID> halfedges_garbage;`
131	`vector<VertexID> vertices_garbage;`	131	`vector<VertexID> vertices_garbage;`
132	`for(int i=0;i<halfedges.size(); ++i)`	132	`for(size_t i=0;i<halfedges.size(); ++i)`
133	`{`	133	`{`
134	`HalfEdgeID h = halfedges[i];`	134	`HalfEdgeID h = halfedges[i];`
135	`HalfEdgeID hopp = kernel.opp(h);`	135	`HalfEdgeID hopp = kernel.opp(h);`
136	`if(kernel.face(hopp) == InvalidFaceID)`	136	`if(kernel.face(hopp) == InvalidFaceID)`
137	`{`	137	`{`
Line 150...	Line 150...
150	`kernel.set_out(v1, kernel.opp(kernel.prev(hopp)));`	150	`kernel.set_out(v1, kernel.opp(kernel.prev(hopp)));`
151	`}`	151	`}`
152		152
153	`}`	153	`}`
154	`}`	154	`}`
155	`for(int i=0;i<halfedges_garbage.size();++i){`	155	`for(size_t i=0;i<halfedges_garbage.size();++i){`
156	`kernel.remove_halfedge(kernel.opp(halfedges_garbage[i]));`	156	`kernel.remove_halfedge(kernel.opp(halfedges_garbage[i]));`
157	`kernel.remove_halfedge(halfedges_garbage[i]);`	157	`kernel.remove_halfedge(halfedges_garbage[i]);`
158	`}`	158	`}`
159	`for(int i=0;i<vertices_garbage.size(); ++i)`	159	`for(size_t i=0;i<vertices_garbage.size(); ++i)`
160	`kernel.remove_vertex(vertices_garbage[i]);`	160	`kernel.remove_vertex(vertices_garbage[i]);`
161		161
162	`kernel.remove_face(fid);`	162	`kernel.remove_face(fid);`
163	`return true;`	163	`return true;`
164	`}`	164	`}`
Line 190...	Line 190...
190	`vector<FaceID> faces;`	190	`vector<FaceID> faces;`
191		191
192	`for(; !w.full_circle(); w = w.circulate_vertex_ccw())`	192	`for(; !w.full_circle(); w = w.circulate_vertex_ccw())`
193	`faces.push_back(w.face());`	193	`faces.push_back(w.face());`
194		194
195	`for(int i=0;i<faces.size();++i)`	195	`for(size_t i=0;i<faces.size();++i)`
196	`remove_face(faces[i]);`	196	`remove_face(faces[i]);`
197		197
198	`return true;`	198	`return true;`
199	`}`	199	`}`
200		200
Line 650...	Line 650...
650	`int did_work;`	650	`int did_work;`
651	`do`	651	`do`
652	`{`	652	`{`
653	`did_work = 0;`	653	`did_work = 0;`
654	`vector<HalfEdgeID> loop_tmp(0);`	654	`vector<HalfEdgeID> loop_tmp(0);`
655	`for(int i=0;i<loop.size();++i)`	655	`for(size_t i=0;i<loop.size();++i)`
656	`if(walker(loop[i]).opp().halfedge() == loop[(i+1)%loop.size()])`	656	`if(walker(loop[i]).opp().halfedge() == loop[(i+1)%loop.size()])`
657	`{`	657	`{`
658	`VertexID vid = walker(loop[i]).vertex();`	658	`VertexID vid = walker(loop[i]).vertex();`
659	`if(vid != v)`	659	`if(vid != v)`
660	`garbage_vertices.push_back(walker(loop[i]).vertex());`	660	`garbage_vertices.push_back(walker(loop[i]).vertex());`
Line 663...	Line 663...
663	`loop[i] = InvalidHalfEdgeID;`	663	`loop[i] = InvalidHalfEdgeID;`
664	`loop[(i+1)%loop.size()] = InvalidHalfEdgeID;`	664	`loop[(i+1)%loop.size()] = InvalidHalfEdgeID;`
665	`++did_work;`	665	`++did_work;`
666	`++i;`	666	`++i;`
667	`}`	667	`}`
668	`for(int i=0;i<loop.size();++i)`	668	`for(size_t i=0;i<loop.size();++i)`
669	`if(loop[i] != InvalidHalfEdgeID)`	669	`if(loop[i] != InvalidHalfEdgeID)`
670	`loop_tmp.push_back(loop[i]);`	670	`loop_tmp.push_back(loop[i]);`
671	`loop = loop_tmp;`	671	`loop = loop_tmp;`
672	`} while(did_work > 0 && loop.size() > 4);`	672	`} while(did_work > 0 && loop.size() > 4);`
673		673
674	`// Check whether the loop is too long`	674	`// Check whether the loop is too long`
675	`float loop_len=0.0;`	675	`float loop_len=0.0;`
676	`for(int i=0;i<loop.size();++i)`	676	`for(size_t i=0;i<loop.size();++i)`
677	`loop_len += length(*this, loop[i]);`	677	`loop_len += length(*this, loop[i]);`
678	`if(loop_len > max_loop_length)`	678	`if(loop_len > max_loop_length)`
679	`return InvalidFaceID;`	679	`return InvalidFaceID;`
680		680
681	`// The following block checks wheteher the same halfedge appears twice. In this`	681	`// The following block checks wheteher the same halfedge appears twice. In this`
Line 685...	Line 685...
685	`vector<HalfEdgeID>::iterator end_iter = unique(loop_tmp.begin(), loop_tmp.end());`	685	`vector<HalfEdgeID>::iterator end_iter = unique(loop_tmp.begin(), loop_tmp.end());`
686	`if(end_iter != loop_tmp.end())`	686	`if(end_iter != loop_tmp.end())`
687	`return InvalidFaceID;`	687	`return InvalidFaceID;`
688		688
689	`// Remove all faces and connected halfedges and the original vertex v.`	689	`// Remove all faces and connected halfedges and the original vertex v.`
690	`for(int i=0;i<garbage_vertices.size(); ++i)`	690	`for(size_t i=0;i<garbage_vertices.size(); ++i)`
691	`kernel.remove_vertex(garbage_vertices[i]);`	691	`kernel.remove_vertex(garbage_vertices[i]);`
692	`for(int i=0;i<garbage_faces.size(); ++i)`	692	`for(size_t i=0;i<garbage_faces.size(); ++i)`
693	`kernel.remove_face(garbage_faces[i]);`	693	`kernel.remove_face(garbage_faces[i]);`
694	`for(int i=0;i<garbage_halfedges.size(); ++i)`	694	`for(size_t i=0;i<garbage_halfedges.size(); ++i)`
695	`kernel.remove_halfedge(garbage_halfedges[i]);`	695	`kernel.remove_halfedge(garbage_halfedges[i]);`
696	`if(!vertex_is_boundary)`	696	`if(!vertex_is_boundary)`
697	`kernel.remove_vertex(v);`	697	`kernel.remove_vertex(v);`
698		698
699	`// Create a new face for the merged one ring and link up all the halfedges`	699	`// Create a new face for the merged one ring and link up all the halfedges`
700	`// in the loop`	700	`// in the loop`
701	`FaceID f = kernel.add_face();`	701	`FaceID f = kernel.add_face();`
702	`kernel.set_last(f,loop[0]);`	702	`kernel.set_last(f,loop[0]);`
703	`for(int i=0;i<loop.size(); ++i)`	703	`for(size_t i=0;i<loop.size(); ++i)`
704	`{`	704	`{`
705	`kernel.set_face(loop[i], f);`	705	`kernel.set_face(loop[i], f);`
706	`Walker hw = walker(loop[i]);`	706	`Walker hw = walker(loop[i]);`
707	`kernel.set_out(hw.vertex(),hw.opp().halfedge());`	707	`kernel.set_out(hw.vertex(),hw.opp().halfedge());`
708	`link(loop[i],loop[(i+1)%loop.size()]);`	708	`link(loop[i],loop[(i+1)%loop.size()]);`
709	`assert(hw.vertex() == walker(loop[(i+1)%loop.size()]).opp().vertex());`	709	`assert(hw.vertex() == walker(loop[(i+1)%loop.size()]).opp().vertex());`
710	`}`	710	`}`
711		711
712	`// Finally, we ensure boundary consitency for all vertices in the loop.`	712	`// Finally, we ensure boundary consitency for all vertices in the loop.`
713	`for(int i=0;i<loop.size(); ++i)`	713	`for(size_t i=0;i<loop.size(); ++i)`
714	`{`	714	`{`
715	`Walker hw = walker(loop[i]);`	715	`Walker hw = walker(loop[i]);`
716	`ensure_boundary_consistency(hw.vertex());`	716	`ensure_boundary_consistency(hw.vertex());`
717	`}`	717	`}`
718		718
Line 848...	Line 848...
848	`const int_type* indices)`	848	`const int_type* indices)`
849	`{`	849	`{`
850	`vector<VertexID> vids(no_vertices);`	850	`vector<VertexID> vids(no_vertices);`
851		851
852	`// create vertices corresponding to positions stored in vertvec`	852	`// create vertices corresponding to positions stored in vertvec`
853	`for(int i=0;i<no_vertices;++i)`	853	`for(size_t i=0;i<no_vertices;++i)`
854	`{`	854	`{`
855	`const float_type* v0 = &vertvec[i*3];`	855	`const float_type* v0 = &vertvec[i*3];`
856	`pos(vids[i] = kernel.add_vertex()) = Manifold::Vec(v0[0], v0[1], v0[2]);`	856	`pos(vids[i] = kernel.add_vertex()) = Manifold::Vec(v0[0], v0[1], v0[2]);`
857	`}`	857	`}`
858		858
Line 1028...	Line 1028...
1028		1028
1029	`// We now create N pairs of edges, glue each pair and let them point to the appropriate`	1029	`// We now create N pairs of edges, glue each pair and let them point to the appropriate`
1030	`// vertices.`	1030	`// vertices.`
1031	`vector<HalfEdgeID> new_halfedges(N);`	1031	`vector<HalfEdgeID> new_halfedges(N);`
1032	`vector<HalfEdgeID> new_halfedges_opp(N);`	1032	`vector<HalfEdgeID> new_halfedges_opp(N);`
1033	`for(int i=0;i<N; ++i)`	1033	`for(size_t i=0;i<N; ++i)`
1034	`{`	1034	`{`
1035	`new_halfedges[i] = kernel.add_halfedge();`	1035	`new_halfedges[i] = kernel.add_halfedge();`
1036	`new_halfedges_opp[i] = kernel.add_halfedge();`	1036	`new_halfedges_opp[i] = kernel.add_halfedge();`
1037	`glue(new_halfedges[i], new_halfedges_opp[i]);`	1037	`glue(new_halfedges[i], new_halfedges_opp[i]);`
1038	`kernel.set_vert(new_halfedges[i], pairs[i].second);`	1038	`kernel.set_vert(new_halfedges[i], pairs[i].second);`
Line 1045...	Line 1045...
1045	`HalfEdgeID h0p = kernel.last(f0);`	1045	`HalfEdgeID h0p = kernel.last(f0);`
1046	`HalfEdgeID h1n = kernel.last(f1);`	1046	`HalfEdgeID h1n = kernel.last(f1);`
1047		1047
1048	`// loop over all connections and link the new halfedges with the old`	1048	`// loop over all connections and link the new halfedges with the old`
1049	`// ones.`	1049	`// ones.`
1050	`for(int i=0;i<N; ++i)`	1050	`for(size_t i=0;i<N; ++i)`
1051	`{`	1051	`{`
1052	`while(kernel.vert(h0p) != pairs[i].first)`	1052	`while(kernel.vert(h0p) != pairs[i].first)`
1053	`h0p = kernel.next(h0p);`	1053	`h0p = kernel.next(h0p);`
1054	`while(kernel.vert(kernel.prev(h1n)) != pairs[i].second)`	1054	`while(kernel.vert(kernel.prev(h1n)) != pairs[i].second)`
1055	`h1n = kernel.prev(h1n);`	1055	`h1n = kernel.prev(h1n);`
Line 1065...	Line 1065...
1065	`h0p = new_halfedges_opp[i];`	1065	`h0p = new_halfedges_opp[i];`
1066	`h1n = new_halfedges_opp[i];`	1066	`h1n = new_halfedges_opp[i];`
1067	`}`	1067	`}`
1068		1068
1069	`// Create the faces and their connections`	1069	`// Create the faces and their connections`
1070	`for(int i=0;i<N; ++i)`	1070	`for(size_t i=0;i<N; ++i)`
1071	`{`	1071	`{`
1072	`HalfEdgeID last = new_halfedges[i];`	1072	`HalfEdgeID last = new_halfedges[i];`
1073	`FaceID f = kernel.add_face();`	1073	`FaceID f = kernel.add_face();`
1074	`kernel.set_last(f, last);`	1074	`kernel.set_last(f, last);`
1075	`HalfEdgeID h = last;`	1075	`HalfEdgeID h = last;`

Subversion Repositories gelsvn

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