void Surface_mesh:: flip(Edge e) { // CAUTION : Flipping a halfedge may result in // a non-manifold mesh, hence check for yourself // whether this operation is allowed or not! //let's make it sure it is actually checked assert(is_flip_ok(e)); Halfedge a0 = halfedge(e, 0); Halfedge b0 = halfedge(e, 1); Halfedge a1 = next_halfedge(a0); Halfedge a2 = next_halfedge(a1); Halfedge b1 = next_halfedge(b0); Halfedge b2 = next_halfedge(b1); Vertex va0 = to_vertex(a0); Vertex va1 = to_vertex(a1); Vertex vb0 = to_vertex(b0); Vertex vb1 = to_vertex(b1); Face fa = face(a0); Face fb = face(b0); set_vertex(a0, va1); set_vertex(b0, vb1); set_next_halfedge(a0, a2); set_next_halfedge(a2, b1); set_next_halfedge(b1, a0); set_next_halfedge(b0, b2); set_next_halfedge(b2, a1); set_next_halfedge(a1, b0); set_face(a1, fb); set_face(b1, fa); set_halfedge(fa, a0); set_halfedge(fb, b0); if (halfedge(va0) == b0) set_halfedge(va0, a1); if (halfedge(vb0) == a0) set_halfedge(vb0, b1); }
void Surface_mesh:: split(Face f, Vertex v) { /* Split an arbitrary face into triangles by connecting each vertex of fh to vh. - fh will remain valid (it will become one of the triangles) - the halfedge handles of the new triangles will point to the old halfeges */ Halfedge hend = halfedge(f); Halfedge h = next_halfedge(hend); Halfedge hold = new_edge(to_vertex(hend), v); set_next_halfedge(hend, hold); set_face(hold, f); hold = opposite_halfedge(hold); while (h != hend) { Halfedge hnext = next_halfedge(h); Face fnew = new_face(); set_halfedge(fnew, h); Halfedge hnew = new_edge(to_vertex(h), v); set_next_halfedge(hnew, hold); set_next_halfedge(hold, h); set_next_halfedge(h, hnew); set_face(hnew, fnew); set_face(hold, fnew); set_face(h, fnew); hold = opposite_halfedge(hnew); h = hnext; } set_next_halfedge(hold, hend); set_next_halfedge(next_halfedge(hend), hold); set_face(hold, f); set_halfedge(v, hold); }
void Surface_mesh:: remove_loop(Halfedge h) { Halfedge h0 = h; Halfedge h1 = next_halfedge(h0); Halfedge o0 = opposite_halfedge(h0); Halfedge o1 = opposite_halfedge(h1); Vertex v0 = to_vertex(h0); Vertex v1 = to_vertex(h1); Face fh = face(h0); Face fo = face(o0); // is it a loop ? assert ((next_halfedge(h1) == h0) && (h1 != o0)); // halfedge -> halfedge set_next_halfedge(h1, next_halfedge(o0)); set_next_halfedge(prev_halfedge(o0), h1); // halfedge -> face set_face(h1, fo); // vertex -> halfedge set_halfedge(v0, h1); adjust_outgoing_halfedge(v0); set_halfedge(v1, o1); adjust_outgoing_halfedge(v1); // face -> halfedge if (fo.is_valid() && halfedge(fo) == o0) set_halfedge(fo, h1); // delete stuff if (!edeleted_) edeleted_ = edge_property<bool>("e:deleted", false); if (!fdeleted_) fdeleted_ = face_property<bool>("f:deleted", false); if (fh.is_valid()) { fdeleted_[fh] = true; ++deleted_faces_; } edeleted_[edge(h0)] = true; ++deleted_edges_; garbage_ = true; }
void Surface_mesh:: triangulate(Face f) { /* Split an arbitrary face into triangles by connecting each vertex of fh after its second to vh. - fh will remain valid (it will become one of the triangles) - the halfedge handles of the new triangles will point to the old halfedges */ Halfedge base_h = halfedge(f); Vertex start_v = from_vertex(base_h); Halfedge next_h = next_halfedge(base_h); while (to_vertex(next_halfedge(next_h)) != start_v) { Halfedge next_next_h(next_halfedge(next_h)); Face new_f = new_face(); set_halfedge(new_f, base_h); Halfedge new_h = new_edge(to_vertex(next_h), start_v); set_next_halfedge(base_h, next_h); set_next_halfedge(next_h, new_h); set_next_halfedge(new_h, base_h); set_face(base_h, new_f); set_face(next_h, new_f); set_face(new_h, new_f); base_h = opposite_halfedge(new_h); next_h = next_next_h; } set_halfedge(f, base_h); //the last face takes the handle _fh set_next_halfedge(base_h, next_h); set_next_halfedge(next_halfedge(next_h), base_h); set_face(base_h, f); }
void test_isolated_vertex() { Graph G; typedef boost::graph_traits< Graph > Traits; typedef typename Traits::vertex_descriptor vertex_descriptor; typedef typename Traits::halfedge_descriptor halfedge_descriptor; vertex_descriptor v = add_vertex(G); // the connectivity of v may be anything set_halfedge(v, Traits::null_halfedge(), G); halfedge_descriptor h = halfedge(v,G); CGAL_USE(h); }
void Surface_mesh:: adjust_outgoing_halfedge(Vertex v) { Halfedge h = halfedge(v); const Halfedge hh = h; if (h.is_valid()) { do { if (is_boundary(h)) { set_halfedge(v, h); return; } h = cw_rotated_halfedge(h); } while (h != hh); } }
void join_face_test() { CGAL_GRAPH_TRAITS_MEMBERS(T); Surface_fixture_1<T> f; bool found; halfedge_descriptor e; boost::tie(e, found) = halfedge(f.w, f.v, f.m); assert(found); // manually set the halfedge of f.f1 to the edge that is to be // removed to provoke a special case set_halfedge(f.f1, e, f.m); CGAL::Euler::join_face(e,f.m); assert(CGAL::internal::exact_num_faces(f.m) == 2); assert(CGAL::internal::exact_num_edges(f.m) == 6); CGAL::Halfedge_around_face_iterator<T> begin, end; boost::tie(begin, end) = CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m); assert(std::distance(begin, end) == 4); for(; begin != end; ++begin) { halfedge_descriptor hd = *begin; assert(face(hd, f.m) == f.f1); } face_iterator fit, fend; for(boost::tie(fit, fend) = faces(f.m); fit != fend; ++fit) { assert(*fit == f.f1 || *fit == f.f3); } assert(degree(f.w, f.m) == 2); assert(degree(f.v, f.m) == 3); assert(CGAL::is_valid(f.m)); }
void Surface_mesh:: split(Edge e, Vertex v) { Halfedge h0 = halfedge(e, 0); Halfedge o0 = halfedge(e, 1); Vertex v2 = to_vertex(o0); Halfedge e1 = new_edge(v, v2); Halfedge t1 = opposite_halfedge(e1); Face f0 = face(h0); Face f3 = face(o0); set_halfedge(v, h0); set_vertex(o0, v); if (!is_boundary(h0)) { Halfedge h1 = next_halfedge(h0); Halfedge h2 = next_halfedge(h1); Vertex v1 = to_vertex(h1); Halfedge e0 = new_edge(v, v1); Halfedge t0 = opposite_halfedge(e0); Face f1 = new_face(); set_halfedge(f0, h0); set_halfedge(f1, h2); set_face(h1, f0); set_face(t0, f0); set_face(h0, f0); set_face(h2, f1); set_face(t1, f1); set_face(e0, f1); set_next_halfedge(h0, h1); set_next_halfedge(h1, t0); set_next_halfedge(t0, h0); set_next_halfedge(e0, h2); set_next_halfedge(h2, t1); set_next_halfedge(t1, e0); } else { set_next_halfedge(prev_halfedge(h0), t1); set_next_halfedge(t1, h0); // halfedge handle of _vh already is h0 } if (!is_boundary(o0)) { Halfedge o1 = next_halfedge(o0); Halfedge o2 = next_halfedge(o1); Vertex v3 = to_vertex(o1); Halfedge e2 = new_edge(v, v3); Halfedge t2 = opposite_halfedge(e2); Face f2 = new_face(); set_halfedge(f2, o1); set_halfedge(f3, o0); set_face(o1, f2); set_face(t2, f2); set_face(e1, f2); set_face(o2, f3); set_face(o0, f3); set_face(e2, f3); set_next_halfedge(e1, o1); set_next_halfedge(o1, t2); set_next_halfedge(t2, e1); set_next_halfedge(o0, e2); set_next_halfedge(e2, o2); set_next_halfedge(o2, o0); } else { set_next_halfedge(e1, next_halfedge(o0)); set_next_halfedge(o0, e1); set_halfedge(v, e1); } if (halfedge(v2) == h0) set_halfedge(v2, t1); }
Surface_mesh::Face Surface_mesh:: add_face(const std::vector<Vertex>& vertices) { Vertex v; unsigned int i, ii, n((int)vertices.size()), id; std::vector<Halfedge> halfedges(n); std::vector<bool> is_new(n), needs_adjust(n, false); Halfedge inner_next, inner_prev, outer_next, outer_prev, boundary_next, boundary_prev, patch_start, patch_end; // cache for set_next_halfedge and vertex' set_halfedge typedef std::pair<Halfedge, Halfedge> NextCacheEntry; typedef std::vector<NextCacheEntry> NextCache; NextCache next_cache; next_cache.reserve(3*n); // don't allow degenerated faces assert (n > 2); // test for topological errors for (i=0, ii=1; i<n; ++i, ++ii, ii%=n) { if ( !is_boundary(vertices[i]) ) { std::cerr << "Surface_meshT::add_face: complex vertex\n"; return Face(); } halfedges[i] = find_halfedge(vertices[i], vertices[ii]); is_new[i] = !halfedges[i].is_valid(); if (!is_new[i] && !is_boundary(halfedges[i])) { std::cerr << "Surface_meshT::add_face: complex edge\n"; return Face(); } } // re-link patches if necessary for (i=0, ii=1; i<n; ++i, ++ii, ii%=n) { if (!is_new[i] && !is_new[ii]) { inner_prev = halfedges[i]; inner_next = halfedges[ii]; if (next_halfedge(inner_prev) != inner_next) { // here comes the ugly part... we have to relink a whole patch // search a free gap // free gap will be between boundary_prev and boundary_next outer_prev = opposite_halfedge(inner_next); outer_next = opposite_halfedge(inner_prev); boundary_prev = outer_prev; do boundary_prev = opposite_halfedge(next_halfedge(boundary_prev)); while (!is_boundary(boundary_prev) || boundary_prev==inner_prev); boundary_next = next_halfedge(boundary_prev); assert(is_boundary(boundary_prev)); assert(is_boundary(boundary_next)); // ok ? if (boundary_next == inner_next) { std::cerr << "Surface_meshT::add_face: patch re-linking failed\n"; return Face(); } // other halfedges' handles patch_start = next_halfedge(inner_prev); patch_end = prev_halfedge(inner_next); // relink next_cache.push_back(NextCacheEntry(boundary_prev, patch_start)); next_cache.push_back(NextCacheEntry(patch_end, boundary_next)); next_cache.push_back(NextCacheEntry(inner_prev, inner_next)); } } } // create missing edges for (i=0, ii=1; i<n; ++i, ++ii, ii%=n) if (is_new[i]) halfedges[i] = new_edge(vertices[i], vertices[ii]); // create the face Face f(new_face()); set_halfedge(f, halfedges[n-1]); // setup halfedges for (i=0, ii=1; i<n; ++i, ++ii, ii%=n) { v = vertices[ii]; inner_prev = halfedges[i]; inner_next = halfedges[ii]; id = 0; if (is_new[i]) id |= 1; if (is_new[ii]) id |= 2; if (id) { outer_prev = opposite_halfedge(inner_next); outer_next = opposite_halfedge(inner_prev); // set outer links switch (id) { case 1: // prev is new, next is old boundary_prev = prev_halfedge(inner_next); next_cache.push_back(NextCacheEntry(boundary_prev, outer_next)); set_halfedge(v, outer_next); break; case 2: // next is new, prev is old boundary_next = next_halfedge(inner_prev); next_cache.push_back(NextCacheEntry(outer_prev, boundary_next)); set_halfedge(v, boundary_next); break; case 3: // both are new if (!halfedge(v).is_valid()) { set_halfedge(v, outer_next); next_cache.push_back(NextCacheEntry(outer_prev, outer_next)); } else { boundary_next = halfedge(v); boundary_prev = prev_halfedge(boundary_next); next_cache.push_back(NextCacheEntry(boundary_prev, outer_next)); next_cache.push_back(NextCacheEntry(outer_prev, boundary_next)); } break; } // set inner link next_cache.push_back(NextCacheEntry(inner_prev, inner_next)); } else needs_adjust[ii] = (halfedge(v) == inner_next); // set face handle set_face(halfedges[i], f); } // process next halfedge cache NextCache::const_iterator ncIt(next_cache.begin()), ncEnd(next_cache.end()); for (; ncIt != ncEnd; ++ncIt) set_next_halfedge(ncIt->first, ncIt->second); // adjust vertices' halfedge handle for (i=0; i<n; ++i) if (needs_adjust[i]) adjust_outgoing_halfedge(vertices[i]); return f; }
void Surface_mesh:: garbage_collection() { if (!garbage_) return; int i, i0, i1, nV(vertices_size()), nE(edges_size()), nH(halfedges_size()), nF(faces_size()); Vertex v; Halfedge h; Face f; if (!vdeleted_) vdeleted_ = vertex_property<bool>("v:deleted", false); if (!edeleted_) edeleted_ = edge_property<bool>("e:deleted", false); if (!fdeleted_) fdeleted_ = face_property<bool>("f:deleted", false); // setup handle mapping Vertex_property<Vertex> vmap = add_vertex_property<Vertex>("v:garbage-collection"); Halfedge_property<Halfedge> hmap = add_halfedge_property<Halfedge>("h:garbage-collection"); Face_property<Face> fmap = add_face_property<Face>("f:garbage-collection"); for (i=0; i<nV; ++i) vmap[Vertex(i)] = Vertex(i); for (i=0; i<nH; ++i) hmap[Halfedge(i)] = Halfedge(i); for (i=0; i<nF; ++i) fmap[Face(i)] = Face(i); // remove deleted vertices if (nV > 0) { i0=0; i1=nV-1; while (1) { // find first deleted and last un-deleted while (!vdeleted_[Vertex(i0)] && i0 < i1) ++i0; while ( vdeleted_[Vertex(i1)] && i0 < i1) --i1; if (i0 >= i1) break; // swap vprops_.swap(i0, i1); //add for(unsigned int j = 0;j<map_2skel.size();j++) { if(map_2skel[j] == i0) map_2skel[j] = i1; else if(map_2skel[j] == i1) map_2skel[j] = i0; } //end }; // remember new size nV = vdeleted_[Vertex(i0)] ? i0 : i0+1; } // remove deleted edges if (nE > 0) { i0=0; i1=nE-1; while (1) { // find first deleted and last un-deleted while (!edeleted_[Edge(i0)] && i0 < i1) ++i0; while ( edeleted_[Edge(i1)] && i0 < i1) --i1; if (i0 >= i1) break; // swap eprops_.swap(i0, i1); hprops_.swap(2*i0, 2*i1); hprops_.swap(2*i0+1, 2*i1+1); }; // remember new size nE = edeleted_[Edge(i0)] ? i0 : i0+1; nH = 2*nE; } // remove deleted faces if (nF > 0) { i0=0; i1=nF-1; while (1) { // find 1st deleted and last un-deleted while (!fdeleted_[Face(i0)] && i0 < i1) ++i0; while ( fdeleted_[Face(i1)] && i0 < i1) --i1; if (i0 >= i1) break; // swap fprops_.swap(i0, i1); }; // remember new size nF = fdeleted_[Face(i0)] ? i0 : i0+1; } // update vertex connectivity for (i=0; i<nV; ++i) { v = Vertex(i); if (!is_isolated(v)) set_halfedge(v, hmap[halfedge(v)]); } // update halfedge connectivity for (i=0; i<nH; ++i) { h = Halfedge(i); set_vertex(h, vmap[to_vertex(h)]); set_next_halfedge(h, hmap[next_halfedge(h)]); if (!is_boundary(h)) set_face(h, fmap[face(h)]); } // update handles of faces for (i=0; i<nF; ++i) { f = Face(i); set_halfedge(f, hmap[halfedge(f)]); } // remove handle maps remove_vertex_property(vmap); remove_halfedge_property(hmap); remove_face_property(fmap); // finally resize arrays vprops_.resize(nV); vprops_.free_memory(); hprops_.resize(nH); hprops_.free_memory(); eprops_.resize(nE); eprops_.free_memory(); fprops_.resize(nF); fprops_.free_memory(); deleted_vertices_ = deleted_edges_ = deleted_faces_ = 0; garbage_ = false; }
void Surface_mesh:: remove_edge(Halfedge h) { Halfedge hn = next_halfedge(h); Halfedge hp = prev_halfedge(h); Halfedge o = opposite_halfedge(h); Halfedge on = next_halfedge(o); Halfedge op = prev_halfedge(o); Face fh = face(h); Face fo = face(o); Vertex vh = to_vertex(h); Vertex vo = to_vertex(o); // halfedge -> vertex Halfedge_around_vertex_circulator vh_it, vh_end; vh_it = vh_end = halfedges(vo); do { set_vertex(opposite_halfedge(vh_it), vh); } while (++vh_it != vh_end); // halfedge -> halfedge set_next_halfedge(hp, hn); set_next_halfedge(op, on); // face -> halfedge if (fh.is_valid()) set_halfedge(fh, hn); if (fo.is_valid()) set_halfedge(fo, on); // vertex -> halfedge if (halfedge(vh) == o) set_halfedge(vh, hn); adjust_outgoing_halfedge(vh); set_halfedge(vo, Halfedge()); // delete stuff if (!vdeleted_) vdeleted_ = vertex_property<bool>("v:deleted", false); if (!edeleted_) edeleted_ = edge_property<bool>("e:deleted", false); vdeleted_[vo] = true; ++deleted_vertices_; edeleted_[edge(h)] = true; ++deleted_edges_; garbage_ = true; //add for(unsigned int j = 0;j < map_2skel.size();j++) { if(map_2skel[j] == vo.idx()) { //unsigned int tem = map_2skel[j]; map_2skel[j] = vh.idx(); //qDebug("vertex:[%d],change %d to %d",j,tem,vh.idx()); } } //end }
void test_validity(Mesh& mesh) { typedef typename boost::graph_traits<Mesh>::vertex_descriptor vertex_descriptor; typedef typename boost::graph_traits<Mesh>::edge_descriptor edge_descriptor; typedef typename boost::graph_traits<Mesh>::face_descriptor face_descriptor; typedef typename boost::property_map<Mesh, CGAL::vertex_point_t>::type VPMap; VPMap vpmap = get(CGAL::vertex_point, mesh); vertex_descriptor vertices[4]; edge_descriptor edges[4]; vertices[0] = add_vertex(mesh); vertices[1] = add_vertex(mesh); vertices[2] = add_vertex(mesh); vertices[3] = add_vertex(mesh); put(vpmap, vertices[0], Point_3(0,0,0)); put(vpmap, vertices[1], Point_3(1,0,0)); put(vpmap, vertices[2], Point_3(1,1,0)); put(vpmap, vertices[3], Point_3(0,1,0)); edges[0] = add_edge(mesh); edges[1] = add_edge(mesh); edges[2] = add_edge(mesh); edges[3] = add_edge(mesh); assert(!CGAL::is_valid_halfedge_graph(mesh)); for(int i=0; i<4; ++i) { set_target(halfedge(edges[i], mesh), vertices[i], mesh); set_halfedge(vertices[i], halfedge(edges[i], mesh), mesh); } for(int i=0; i<4; ++i) set_target(opposite(halfedge(edges[i], mesh), mesh), vertices[(i+1)%4], mesh); for(int i=0; i<4; ++i) { set_next(halfedge(edges[(i+1)%4], mesh), halfedge(edges[i], mesh), mesh); set_next(opposite(halfedge(edges[i], mesh), mesh), opposite(halfedge(edges[(i+1)%4], mesh), mesh), mesh); } assert(CGAL::is_valid_halfedge_graph(mesh)); face_descriptor faces[1]; faces[0] = add_face(mesh); assert(!CGAL::is_valid_face_graph(mesh)); for(int i=0; i<4; ++i) { set_face(opposite(halfedge(edges[i], mesh), mesh), faces[0], mesh); } set_halfedge(faces[0], opposite(halfedge(edges[0], mesh), mesh), mesh); assert(CGAL::is_valid_face_graph(mesh)); assert(CGAL::is_valid_polygon_mesh(mesh)); Mesh dummy; vertices[0] = add_vertex(dummy); vertices[1] = add_vertex(dummy); edges[0] = add_edge(dummy); set_target(halfedge(edges[0], dummy), vertices[0], dummy); set_halfedge(vertices[0], halfedge(edges[0], dummy), dummy); set_target(opposite(halfedge(edges[0], dummy), dummy), vertices[1], dummy); set_halfedge(vertices[1], opposite(halfedge(edges[0], dummy), dummy), dummy); set_next(halfedge(edges[0], dummy), opposite(halfedge(edges[0], dummy), dummy), dummy); set_next(opposite(halfedge(edges[0], dummy), dummy), halfedge(edges[0], dummy), dummy); faces[0] = add_face(dummy); set_halfedge(faces[0], opposite(halfedge(edges[0], dummy), dummy), dummy); set_face(halfedge(edges[0], dummy), faces[0], dummy); set_face(opposite(halfedge(edges[0], dummy), dummy), faces[0], dummy); assert(CGAL::is_valid_face_graph(dummy)); assert(!CGAL::is_valid_polygon_mesh(dummy)); }