void Polyhedron_demo_mesh_simplification_plugin::on_actionSimplify_triggered()
{
const CGAL::Three::Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(item)
{
Polyhedron* pMesh = item->polyhedron();
// get option (#edges)
bool ok;
const int nb_edges =
QInputDialog::getInt(mw, tr("Stop condition"),
tr("Number of edges:"),
(int)(pMesh->size_of_halfedges () / 4), // default value: current #edges / 2
3, // min = one triangle
(int)pMesh->size_of_halfedges(), // max #edges
1, // step for the spinbox
&ok);
// check user cancellation
if(!ok)
return;
// simplify
QTime time;
time.start();
std::cout << "Simplify...";
QApplication::setOverrideCursor(Qt::WaitCursor);
namespace SMS = CGAL::Surface_mesh_simplification;
SMS::Count_stop_predicate< Polyhedron > stop(nb_edges); // target #edges
SMS::edge_collapse( *pMesh, stop,
CGAL::parameters::vertex_index_map(get(CGAL::vertex_external_index,*pMesh))
.halfedge_index_map(get(CGAL::halfedge_external_index,*pMesh)));
std::cout << "ok (" << time.elapsed() << " ms, "
<< pMesh->size_of_halfedges() / 2 << " edges)" << std::endl;
// update scene
item->invalidate_buffers();
scene->itemChanged(index);
QApplication::restoreOverrideCursor();
}
}
void Polyhedron_demo_subdivision_methods_plugin::on_actionLoop_triggered()
{
Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(!item) return;
Polyhedron* poly = item->polyhedron();
QTime time;
time.start();
std::cout << "Loop subdivision...";
QApplication::setOverrideCursor(Qt::WaitCursor);
CGAL::Subdivision_method_3::Loop_subdivision(*poly, 1);
std::cout << "ok (" << time.elapsed() << " ms)" << std::endl;
QApplication::restoreOverrideCursor();
scene->itemChanged(item);
}
void Polyhedron_demo_self_intersection_plugin::on_actionSelfIntersection_triggered()
{
CGAL::Three::Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(item)
{
Polyhedron* pMesh = item->polyhedron();
// compute self-intersections
typedef Polyhedron::Facet_handle Facet_handle;
std::vector<std::pair<Facet_handle, Facet_handle> > facets;
CGAL::Polygon_mesh_processing::self_intersections
(*pMesh, std::back_inserter(facets),
CGAL::Polygon_mesh_processing::parameters::vertex_point_map(get(CGAL::vertex_point, *pMesh)));
std::cout << "ok (" << facets.size() << " triangle pair(s))" << std::endl;
// add intersecting triangles as a new polyhedron, i.e., a triangle soup.
if(!facets.empty())
{
Scene_polyhedron_selection_item* selection_item = new Scene_polyhedron_selection_item(item, mw);
for(std::vector<std::pair<Facet_handle, Facet_handle> >::iterator fb = facets.begin();
fb != facets.end(); ++fb) {
selection_item->selected_facets.insert(fb->first);
selection_item->selected_facets.insert(fb->second);
}
selection_item->invalidateOpenGLBuffers();
selection_item->setName(tr("%1 (selection) (intersecting triangles)").arg(item->name()));
item->setRenderingMode(Wireframe);
scene->addItem(selection_item);
scene->itemChanged(item);
scene->itemChanged(selection_item);
}
else
QMessageBox::information(mw, tr("No self intersection"),
tr("The polyhedron \"%1\" does not self-intersect.").
arg(item->name()));
}
}
void Polyhedron_demo_self_intersection_plugin::on_actionSelfIntersection_triggered()
{
Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(item)
{
Polyhedron* pMesh = item->polyhedron();
// compute self-intersections
typedef std::list<Triangle>::iterator Iterator;
std::list<Triangle> triangles; // intersecting triangles
typedef std::back_insert_iterator<std::list<Triangle> > OutputIterator;
std::cout << "Self-intersect...";
::self_intersect<Polyhedron,Kernel,OutputIterator>(*pMesh,std::back_inserter(triangles));
std::cout << "ok (" << triangles.size() << " triangle(s))" << std::endl;
// add intersecting triangles as a new polyhedron, i.e., a triangle soup.
if(triangles.size() != 0)
{
Polyhedron *pSoup = new Polyhedron;
Make_triangle_soup<Polyhedron,Kernel,Iterator> soup_builder;
soup_builder.run(triangles.begin(),triangles.end(),*pSoup);
Scene_polyhedron_item* new_item = new Scene_polyhedron_item(pSoup);
new_item->setName(tr("%1 (intersecting triangles)").arg(item->name()));
new_item->setColor(Qt::magenta);
new_item->setRenderingMode(item->renderingMode());
scene->addItem(new_item);
item->setRenderingMode(Wireframe);
scene->itemChanged(item);
}
else
QMessageBox::information(mw, tr("No self intersection"),
tr("The polyhedron \"%1\" does not self-intersect.").
arg(item->name()));
}
}
void Polyhedron_demo_kernel_plugin::on_actionKernel_triggered()
{
const Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(item)
{
Polyhedron* pMesh = item->polyhedron();
typedef CGAL::Exact_integer ET; // choose exact integral type
typedef Polyhedron_kernel<Kernel,ET> Polyhedron_kernel;
// get triangles from polyhedron
std::list<Triangle> triangles;
get_triangles(*pMesh,std::back_inserter(triangles));
// solve LP
std::cout << "Solve linear program...";
Polyhedron_kernel kernel;
if(!kernel.solve(triangles.begin(),triangles.end()))
{
std::cout << "done (empty kernel)" << std::endl;
QMessageBox::information(mw, tr("Empty kernel"),
tr("The kernel of the polyhedron \"%1\" is empty.").
arg(item->name()));
QApplication::restoreOverrideCursor();
return;
}
std::cout << "done" << std::endl;
// add kernel as new polyhedron
Polyhedron *pKernel = new Polyhedron;
// get inside point
Point inside_point = kernel.inside_point();
Vector translate = inside_point - CGAL::ORIGIN;
// compute dual of translated polyhedron w.r.t. inside point.
std::cout << "Compute dual of translated polyhedron...";
std::list<Point> dual_points;
std::list<Triangle>::iterator it;
for(it = triangles.begin();
it != triangles.end();
it++)
{
const Triangle& triangle = *it;
const Point p0 = triangle[0] - translate;
const Point p1 = triangle[1] - translate;
const Point p2 = triangle[2] - translate;
Plane plane(p0,p1,p2);
Vector normal = plane.orthogonal_vector();
normal = normal / std::sqrt(normal*normal);
// compute distance to origin (do not use plane.d())
FT distance_to_origin = std::sqrt(CGAL::squared_distance(Point(CGAL::ORIGIN),plane));
Point dual_point = CGAL::ORIGIN + normal / distance_to_origin;
dual_points.push_back(dual_point);
}
std::cout << "ok" << std::endl;
// compute convex hull in dual space
std::cout << "convex hull in dual space...";
Polyhedron convex_hull;
CGAL::convex_hull_3(dual_points.begin(),dual_points.end(),convex_hull);
std::cout << "ok" << std::endl;
// dualize and translate back to get final kernel
Dualizer<Polyhedron,Kernel> dualizer;
dualizer.run(convex_hull,*pKernel);
::translate<Polyhedron,Kernel>(*pKernel,translate);
pKernel->inside_out();
Scene_polyhedron_item* new_item = new Scene_polyhedron_item(pKernel);
new_item->setName(tr("%1 (kernel)").arg(item->name()));
new_item->setColor(Qt::magenta);
new_item->setRenderingMode(item->renderingMode());
scene->addItem(new_item);
item->setRenderingMode(Wireframe);
scene->itemChanged(item);
QApplication::restoreOverrideCursor();
}
}
