void geometryUtils::subdivide(Polyhedron& P) {
if (P.size_of_facets() == 0)
return;
// We use that new vertices/halfedges/facets are appended at the end.
std::size_t nv = P.size_of_vertices();
Vertex_iterator last_v = P.vertices_end();
--last_v; // the last of the old vertices
Edge_iterator last_e = P.edges_end();
--last_e; // the last of the old edges
Facet_iterator last_f = P.facets_end();
--last_f; // the last of the old facets
Facet_iterator f = P.facets_begin(); // create new center vertices
do {
geometryUtils::subdivide_create_center_vertex(P, f);
} while (f++ != last_f);
std::vector<Point_3> pts; // smooth the old vertices
pts.reserve(nv); // get intermediate space for the new points
++last_v; // make it the past-the-end position again
std::transform(P.vertices_begin(), last_v, std::back_inserter(pts),
Smooth_old_vertex());
std::copy(pts.begin(), pts.end(), P.points_begin());
Edge_iterator e = P.edges_begin(); // flip the old edges
++last_e; // make it the past-the-end position again
while (e != last_e) {
Halfedge_handle h = e;
++e; // careful, incr. before flip since flip destroys current edge
geometryUtils::subdivide_flip_edge(P, h);
};
CGAL_postcondition(P.is_valid());
};
bool is_weakly_convex(Polyhedron const& p) {
for (typename Polyhedron::Edge_const_iterator i = p.edges_begin(); i != p.edges_end(); ++i) {
typename Polyhedron::Plane_3 p(i->opposite()->vertex()->point(), i->vertex()->point(), i->next()->vertex()->point());
if (p.has_on_positive_side(i->opposite()->next()->vertex()->point()) &&
CGAL::squared_distance(p, i->opposite()->next()->vertex()->point()) > 1e-8) {
return false;
}
}
// Also make sure that there is only one shell:
boost::unordered_set<typename Polyhedron::Facet_const_handle, typename CGAL::Handle_hash_function> visited;
// c++11
// visited.reserve(p.size_of_facets());
std::queue<typename Polyhedron::Facet_const_handle> to_explore;
to_explore.push(p.facets_begin()); // One arbitrary facet
visited.insert(to_explore.front());
while (!to_explore.empty()) {
typename Polyhedron::Facet_const_handle f = to_explore.front();
to_explore.pop();
typename Polyhedron::Facet::Halfedge_around_facet_const_circulator he, end;
end = he = f->facet_begin();
CGAL_For_all(he,end) {
typename Polyhedron::Facet_const_handle o = he->opposite()->facet();
if (!visited.count(o)) {
visited.insert(o);
to_explore.push(o);
}
}
}
void SetEdgeWeightsEuclidean(Polyhedron& P)
{
edge_descriptor e(P.edges_begin());
edge_descriptor e_end(P.edges_end());
for(; e!=e_end; e=e.next())
{
e.halfedge()->weight (sqrt( (e.halfedge()->vertex()->point() - e.opposite().halfedge()->vertex()->point()).squared_length() ));
e.opposite().halfedge()->weight(e.halfedge()->weight());
}
}
void subdiv_border( Polyhedron& P) {
if ( P.size_of_facets() == 0)
return;
// We use that new halfedges are appended at the end.
Edge_iterator last_e = P.edges_end();
-- last_e; // the last of the old edges
Edge_iterator e = P.edges_begin(); // create trisected border edges
do {
if ( e->opposite()->is_border())
trisect_border_halfedge( P, e->opposite());
else if ( e->is_border())
trisect_border_halfedge( P, e);
} while ( e++ != last_e);
e = P.edges_begin(); // smooth points on border edges
std::vector<Point> pts; // store new smoothed points temporarily
do {
if ( e->opposite()->is_border())
smooth_border_vertices( e->opposite(), std::back_inserter(pts));
else if ( e->is_border())
smooth_border_vertices( e, std::back_inserter(pts));
} while ( e++ != last_e);
e = P.edges_begin(); // copy smoothed points back
std::vector<Point>::iterator i = pts.begin();
do {
if ( e->opposite()->is_border()) {
e->vertex()->point() = *i++;
e->opposite()->vertex()->point() = *i++;
e->opposite()->next()->vertex()->point() = *i++;
} else if ( e->is_border()) {
e->opposite()->vertex()->point() = *i++;
e->vertex()->point() = *i++;
e->next()->vertex()->point() = *i++;
}
} while ( e++ != last_e);
CGAL_assertion( i == pts.end());
CGAL_postcondition( P.is_valid());
}
// a helper method for running different iterators
void running_iterators( Polyhedron& P) {
if ( P.size_of_facets() == 0)
return;
std::size_t nv = P.size_of_vertices();
std::cout << "The number of vertices in the Polyhedron: " << nv << std::endl;
std::cout << "The number of facets in the Polyhedron: " << P.size_of_facets() << std::endl;
std::cout << "The number of half edges in the Polyhedron: " << P.size_of_halfedges() << std::endl;
std::cout << std:: endl;
Polyhedron::Vertex_iterator last_v = P.vertices_end();
-- last_v; // the last of the old vertices
Polyhedron::Edge_iterator last_e = P.edges_end();
-- last_e; // the last of the old edges
Polyhedron::Facet_iterator last_f = P.facets_end();
-- last_f; // the last of the old facets
int k = 0;
Polyhedron::Facet_iterator f = P.facets_begin();
do {
std::cout << "Printing a facet index: " << k++ << std::endl;
f->halfedge();
} while ( f++ != last_f);
std::cout << std::endl;
// -------------------------------------------------
// traverse the vertices
// -------------------------------------------------
std::cout << "Printing the vertex indices: " << std::endl;
int n=0;
for (Polyhedron::Vertex_iterator vi = P.vertices_begin(); vi != P.vertices_end(); ++vi)
{
Kernel::Point_3 p;
p = vi->point();
std::cout << "Vertex index: " << n++ << std::endl;
std::cout << "p.x() = " << p.x() << std::endl;
std::cout << "p.y() = " << p.y() << std::endl;
std::cout << "p.z() = " << p.z() << std::endl;
}
std::cout << std::endl;
// -------------------------------------------------
// traverse the edges
// -------------------------------------------------
std::cout << "Iterating over the edges.... " << std::endl;
n=0;
for (Polyhedron::Edge_iterator ei = P.edges_begin(); ei != P.edges_end(); ++ei)
{
ei->next();
Kernel::Point_3 p;
p = ei->vertex()->point();
std::cout << "For edge index: " << n++ << std::endl;
std::cout << "p.x() = " << p.x() << std::endl;
std::cout << "p.y() = " << p.y() << std::endl;
std::cout << "p.z() = " << p.z() << std::endl;
}
std::cout << std::endl;
// -----------------------------------------------
// Do something else with the edge iterators
// -----------------------------------------------
Polyhedron::Edge_iterator e = P.edges_begin();
++ last_e; // make it the past-the-end position again
while ( e != last_e) {
Polyhedron::Halfedge_handle h = e;
++e;
};
CGAL_postcondition( P.is_valid());
}
