Reconstruction from parallel slices

Installation/include/CGAL/license/Reconstruction_parallel_slices_3.h

@@ -0,0 +1,54 @@
+// Copyright (c) 2016  GeometryFactory SARL (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org)
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
+//
+// Author(s) : Andreas Fabri
+//
+// Warning: this file is generated, see include/CGAL/licence/README.md
+
+#ifndef CGAL_LICENSE_RECONSTRUCTION_PARALLEL_SLICES_3_H
+#define CGAL_LICENSE_RECONSTRUCTION_PARALLEL_SLICES_3_H
+
+#include <CGAL/config.h>
+#include <CGAL/license.h>
+
+#ifdef CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE
+
+#  if CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE < CGAL_RELEASE_DATE
+
+#    if defined(CGAL_LICENSE_WARNING)
+
+       CGAL_pragma_warning("Your commercial license for CGAL does not cover "
+                           "this release of the Reconstruction from 3D Parallel Slices package.")
+#    endif
+
+#    ifdef CGAL_LICENSE_ERROR
+#      error "Your commercial license for CGAL does not cover this release \
+              of the Reconstruction from 3D Parallel Slices package. \
+              You get this error, as you defined CGAL_LICENSE_ERROR."
+#    endif // CGAL_LICENSE_ERROR
+
+#  endif // CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE < CGAL_RELEASE_DATE
+
+#else // no CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE
+
+#  if defined(CGAL_LICENSE_WARNING)
+     CGAL_pragma_warning("\nThe macro CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE is not defined."
+                          "\nYou use the CGAL Reconstruction from 3D Parallel Slices package under "
+                          "the terms of the GPLv3+.")
+#  endif // CGAL_LICENSE_WARNING
+
+#  ifdef CGAL_LICENSE_ERROR
+#    error "The macro CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE is not defined.\
+            You use the CGAL Reconstruction from 3D Parallel Slices package under the terms of \
+            the GPLv3+. You get this error, as you defined CGAL_LICENSE_ERROR."
+#  endif // CGAL_LICENSE_ERROR
+
+#endif // no CGAL_RECONSTRUCTION_PARALLEL_SLICES_3_COMMERCIAL_LICENSE
+
+#endif // CGAL_LICENSE_RECONSTRUCTION_PARALLEL_SLICES_3_H

Installation/include/CGAL/license/gpl_package_list.txt

@@ -63,6 +63,7 @@ Polyline_simplification_2 2D Polyline Simplification
 Polytope_distance_d Optimal Distances
 Principal_component_analysis Principal Component Analysis
 QP_solver Linear and Quadratic Programming Solver
+Reconstruction_parallel_slices_3 Reconstruction from 3D Parallel Slices
 Ridges_3 Approximation of Ridges and Umbilics on Triangulated Surface Meshes
 Scale_space_reconstruction_3 Scale-Space Surface Reconstruction
 SearchStructures dD Range and Segment Trees

Polyhedron/demo/Polyhedron/Plugins/Reconstruction_from_slices/CMakeLists.txt

@@ -0,0 +1,4 @@
+include( polyhedron_demo_macros )
+
+polyhedron_demo_plugin(reconstruction_parallel_slices_plugin Reconstruction_parallel_slices_plugin)
+target_link_libraries(reconstruction_parallel_slices_plugin PUBLIC scene_surface_mesh_item scene_polylines_item)

Polyhedron/demo/Polyhedron/Plugins/Reconstruction_from_slices/Reconstruction_parallel_slices_plugin.cpp

@@ -0,0 +1,207 @@
+#include <QElapsedTimer>
+#include <QApplication>
+#include <QAction>
+#include <QStringList>
+#include <QMainWindow>
+#include <QtPlugin>
+#include <QMessageBox>
+
+
+#include "Scene_surface_mesh_item.h"
+#include "Scene_polylines_item.h"
+
+#include <CGAL/Three/Polyhedron_demo_plugin_interface.h>
+#include <CGAL/Three/Polyhedron_demo_plugin_helper.h>
+
+#include <CGAL/Reconstruction_from_parallel_slices_3.h>
+#include <CGAL/Reconstruction_from_parallel_slices_3/contour_providers.h>
+
+
+using namespace CGAL::Three;
+class Polyhedron_demo_reconstruction_parallel_slices_plugin :
+  public QObject,
+  public Polyhedron_demo_plugin_interface
+{
+  Q_OBJECT
+  Q_INTERFACES(CGAL::Three::Polyhedron_demo_plugin_interface)
+  Q_PLUGIN_METADATA(IID "com.geometryfactory.PolyhedronDemo.PluginInterface/1.0")
+  QList<QAction*> _actions;
+  Scene_interface* scene;
+  QMainWindow* mw;
+  int detect_constant_coordinate(Scene_polylines_item* polylines_item);
+
+public:
+  void init(QMainWindow* mainWindow, CGAL::Three::Scene_interface* scene_interface, Messages_interface*) {
+    QAction* actionReconstructionParallelSlices = new QAction(tr("Reconstruction from parallel slices"), mainWindow);
+    actionReconstructionParallelSlices->setObjectName("actionReconstructionParallelSlices");
+    connect(actionReconstructionParallelSlices, SIGNAL(triggered()), this, SLOT(on_actionReconstructionParallelSlices_triggered()));
+    _actions << actionReconstructionParallelSlices;
+    scene = scene_interface;
+    mw=mainWindow;
+  }
+
+  QList<QAction*> actions()const {return _actions;}
+
+  // used by Polyhedron_demo_plugin_helper
+  QStringList actionsNames() const {
+    return QStringList() << "actionReconstructionParallelSlices";
+  }
+
+  bool applicable(QAction*) const {
+    return qobject_cast<Scene_polylines_item*>(scene->item(scene->mainSelectionIndex()));
+  }
+
+public Q_SLOTS:
+  void on_actionReconstructionParallelSlices_triggered();
+
+}; // end Polyhedron_demo_reconstruction_parallel_slices_plugin
+
+
+int Polyhedron_demo_reconstruction_parallel_slices_plugin::detect_constant_coordinate(Scene_polylines_item* polylines_item)
+{
+  typedef Scene_polylines_item::Point_3 Point_3;
+  typedef std::vector<Point_3> Polyline;
+  typedef std::list<Polyline> Polylines_container;
+  Polylines_container& polylines=polylines_item->polylines;
+
+  Polylines_container::size_type nb_polylines=polylines.size();
+
+  switch (nb_polylines)
+  {
+    case 0:
+    case 1:
+      QMessageBox::warning(mw, tr("Error"),
+                     tr("The selected polylines item must contains at least two contours."));
+      return -1;
+    default:
+    {
+      Polylines_container::iterator it_poly=polylines.begin();
+      std::vector<int> const_coords;
+      const_coords.reserve(3);
+      const_coords.push_back(0);
+      const_coords.push_back(1);
+      const_coords.push_back(2);
+
+      while(it_poly!=polylines.end())
+      {
+        Polyline& polyline = *it_poly++;
+        if ( polyline.size()==1 ) continue;
+
+        Point_3 pt=polyline[0];
+
+        for (Polyline::iterator it_pt=CGAL::cpp11::next( polyline.begin() );it_pt!=polyline.end();++it_pt)
+        {
+          std::vector<int> to_keep;
+          std::vector<int>::size_type nc=const_coords.size();
+          for (std::vector<int>::size_type i=0;i<nc;++i)
+            if ( pt[ const_coords[i] ] == (*it_pt)[ const_coords[i] ] ) to_keep.push_back( const_coords[i] );
+          switch( to_keep.size() )
+          {
+            case 0:
+              QMessageBox::warning(mw, tr("Error"),
+                             tr("The selected polylines item are not contained in parallel slices."));
+              return -1;
+            case 1:
+              return to_keep[0];
+            default:
+              const_coords=to_keep;
+          }
+        }
+      }
+      QMessageBox::warning(mw, tr("Error"),
+                     tr("The selected polylines item are not contained in parallel slices."));
+      return -1;
+    }
+  }
+}
+
+typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
+typedef CGAL::Polyhedron_3<K> Polyhedron;
+
+struct Visitor_update{
+  Scene_surface_mesh_item* m_item;
+  const Polyhedron& m_reconst; // TODO update code to directly use Surface mesh
+
+  Visitor_update(Scene_surface_mesh_item* item, const Polyhedron& reconst)
+    : m_item(item)
+    , m_reconst(reconst)
+  {}
+
+  void one_layer_is_finished() {
+    m_item->face_graph()->clear();
+    CGAL::copy_face_graph(m_reconst, *m_item->face_graph());
+
+    m_item->invalidateOpenGLBuffers();
+    m_item->redraw();
+    m_item->itemChanged();
+    QApplication::processEvents();
+  }
+};
+
+void Polyhedron_demo_reconstruction_parallel_slices_plugin::on_actionReconstructionParallelSlices_triggered()
+{
+
+  typedef CGAL::Polygon_as_vector_of_Point_3_in_axis_aligned_planes<K,Scene_polylines_item::Polylines_container> Contour_reader;
+  typedef CGAL::Incremental_slice_writer_into_polyhedron<Polyhedron,K,Visitor_update> Slice_writer;
+
+  const Scene_interface::Item_id index = scene->mainSelectionIndex();
+
+  Scene_polylines_item* polylines_item =
+    qobject_cast<Scene_polylines_item*>(scene->item(index));
+
+  if(polylines_item)
+  {
+    // wait cursor
+    QApplication::setOverrideCursor(Qt::WaitCursor);
+
+    std::cout << "Analysing input...";
+    int cst_coord = detect_constant_coordinate(polylines_item);
+    if ( cst_coord == -1 ) return;
+
+    switch (cst_coord)
+    {
+      case 0:
+        std::cout << "  Constant coordinate is X"<< std::endl;
+        break;
+      case 1:
+        std::cout << "  Constant coordinate is Y"<< std::endl;
+        break;
+      case 2:
+        std::cout << "  Constant coordinate is Z"<< std::endl;
+        break;
+      default:
+        std::cout << "  Invalid input."<< std::endl;
+        break;
+        return;
+    }
+
+    QElapsedTimer time;
+    time.start();
+    std::cout << "Reconstructing ...";
+
+    // add a new polyhedron
+    Polyhedron reconst;
+
+    Scene_surface_mesh_item* new_item = new Scene_surface_mesh_item();
+    new_item->setName(tr("%1 (reconstruction)").arg(polylines_item->name()));
+    int item_index=scene->addItem(new_item);
+
+    Visitor_update vis_update(new_item, reconst);
+    //slice writer writing in a polyhedron
+    Slice_writer writer(reconst,vis_update);
+
+    Contour_reader reader(polylines_item->polylines, cst_coord);
+    CGAL::Reconstruction_from_parallel_slices_3<Slice_writer> reconstruction;
+    reconstruction.run(reader,writer,cst_coord);
+
+    new_item->invalidateOpenGLBuffers();
+    scene->itemChanged(item_index);
+
+    std::cout << "ok (" << time.elapsed() << " ms)" << std::endl;
+
+    // default cursor
+    QApplication::restoreOverrideCursor();
+  }
+}
+
+#include "Reconstruction_parallel_slices_plugin.moc"

Reconstruction_parallel_slices_3/examples/Reconstruction_parallel_slices_3/CMakeLists.txt

@@ -0,0 +1,16 @@
+# Created by the script cgal_create_cmake_script
+# This is the CMake script for compiling a CGAL application.
+
+cmake_minimum_required(VERSION 3.1...3.15)
+project(Reconstruction_parallel_slices_3_Examples)
+
+find_package(CGAL REQUIRED)
+
+create_single_source_cgal_program( "conforming-Delaunay_3.cpp" )
+create_single_source_cgal_program( "manifold_check.cpp" )
+create_single_source_cgal_program( "check_valid_input.cpp" )
+create_single_source_cgal_program( "edge_profile.cpp" )
+create_single_source_cgal_program( "repair.cpp" )
+create_single_source_cgal_program( "extract.cpp" )
+create_single_source_cgal_program( "detect_intersecting_segments.cpp" )
+