void
Polyhedron_demo_nef_plugin::on_actionToNef_triggered()
{
const Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* item =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
if(item)
{
QApplication::setOverrideCursor(Qt::WaitCursor);
QTime time;
time.start();
std::cerr << "Convert polyhedron to nef polyhedron...";
Scene_nef_polyhedron_item* new_nef_item =
Scene_nef_polyhedron_item::from_polyhedron(item);
new_nef_item->setName(tr("%1 (to nef)").arg(item->name()));
new_nef_item->setRenderingMode(item->renderingMode());
item->setVisible(false);
scene->itemChanged(index);
scene->addItem(new_nef_item);
std::cerr << "ok (" << time.elapsed() << " ms)" << std::endl;
QApplication::restoreOverrideCursor();
}
}
void Scene_c3t3_item::export_facets_in_complex()
{
std::stringstream off_sstream;
c3t3().output_facets_in_complex_to_off(off_sstream);
std::string backup = off_sstream.str();
// Try to read .off in a polyhedron
Scene_polyhedron_item* item = new Scene_polyhedron_item;
if (!item->load(off_sstream))
{
delete item;
off_sstream.str(backup);
// Try to read .off in a polygon soup
Scene_polygon_soup_item* soup_item = new Scene_polygon_soup_item;
if (!soup_item->load(off_sstream)) {
delete soup_item;
return;
}
soup_item->setName(QString("%1_%2").arg(this->name()).arg("facets"));
last_known_scene->addItem(soup_item);
}
else{
item->setName(QString("%1_%2").arg(this->name()).arg("facets"));
last_known_scene->addItem(item);
}
}
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_nef_plugin::on_actionConvexDecomposition_triggered()
{
const Scene_interface::Item_id index = scene->mainSelectionIndex();
Scene_polyhedron_item* pitem =
qobject_cast<Scene_polyhedron_item*>(scene->item(index));
Scene_nef_polyhedron_item* item =
(pitem)? Scene_nef_polyhedron_item::from_polyhedron(pitem)
: qobject_cast<Scene_nef_polyhedron_item*>(scene->item(index));
if(item) {
QTime time;
time.start();
std::cerr << "Convex decomposition...";
QApplication::setOverrideCursor(Qt::WaitCursor);
std::list<Scene_polyhedron_item*> convex_parts;
item->convex_decomposition(convex_parts);
int i = 0;
for(std::list<Scene_polyhedron_item*>::iterator it = convex_parts.begin();
it != convex_parts.end();
++it){
(*it)->setName(tr("part %1 of %2").arg(i++).arg(item->name()));
(*it)->setRenderingMode(item->renderingMode());
scene->addItem(*it);
}
if(pitem){
delete item;
pitem->setVisible(false);
} else {
item->setVisible(false);
}
std::cerr << "ok (" << time.elapsed() << " ms)" << std::endl;
QApplication::restoreOverrideCursor();
} else {
std::cerr << "Only a Polyhedron or a Nef Polyhedron can be decomposed in convex parts" << std::endl;
}
}
CGAL::Three::Scene_item*
Polyhedron_demo_off_plugin::load_obj(QFileInfo fileinfo) {
// Open file
std::ifstream in(fileinfo.filePath().toUtf8());
if(!in) {
std::cerr << "Error! Cannot open file " << (const char*)fileinfo.filePath().toUtf8() << std::endl;
return NULL;
}
// Try to read .obj in a polyhedron
Scene_polyhedron_item* item = new Scene_polyhedron_item();
item->setName(fileinfo.completeBaseName());
if(!item->load_obj(in))
{
delete item;
return 0;
}
return item;
}
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();
}
}
