Merge remote-tracking branch 'cgal/6.0.x-branch'

Documentation/doc/Documentation/Third_party.txt

@@ -283,6 +283,8 @@ requires solving complex non-linear least squares problems.
 Visit the official website of the library at <A HREF="http://ceres-solver.org/index.html">`ceres-solver.org`</A>
 for more information.
 
+\attention \ceres requires to be compiled with the exact same version of \eigen that is used for \cgal.
+
 \attention \ceres indicates that `glog` is a recommended dependency. `glog` has `libunwind` as a recommended dependency.
 On some platforms, linking with `libunwind` was responsible for an increase of the runtime of the final application.
 If you experience such an issue, we recommend to compile \ceres without `glog` support.
@@ -309,7 +311,7 @@ The \scip web site is <A HREF="https://www.scipopt.org/">`https://www.scipopt.or
 
 \osqp (Operator Splitting Quadratic Program) is currently one of the fastest open source solvers for convex Quadratic Programs (QP).
 
-In \cgal, \osqp provides an optional solver for the QP problems often arising in various computational geometry algorithms.
+In \cgal, \osqp provides an optional solver for the quadratic programming used in the \ref PkgShapeRegularization package.
 In order to use \osqp in \cgal programs, the executables should be linked with the CMake imported target `CGAL::OSQP_support` provided in `CGAL_OSQP_support.cmake`.
 
 The \osqp web site is <A HREF="https://osqp.org">`https://osqp.org`</A>.

Kinetic_space_partition/include/CGAL/KSP_3/Intersection_graph.h

@@ -289,9 +289,8 @@ public:
     m_initial_intervals.resize(e.size());
 
     std::size_t idx = 0;
-    for (const auto& edge : e) {
+    for (const auto& edge : e)
       m_initial_intervals[idx++] = m_graph[edge].intervals;
-    }
 
     m_initial_part_of_partition.resize(m_ifaces.size());
     for (idx = 0; idx < m_ifaces.size(); idx++)
@@ -303,9 +302,8 @@ public:
     CGAL_assertion(e.size() == m_initial_intervals.size());
     std::size_t idx = 0;
 
-    for (auto edge : e) {
+    for (auto edge : e)
-      m_graph[edge].intervals = m_initial_intervals[idx];
+      m_graph[edge].intervals = m_initial_intervals[idx++];
-    }
 
     CGAL_assertion(m_ifaces.size() == m_initial_part_of_partition.size());
     for (idx = 0; idx < m_ifaces.size(); idx++)

Kinetic_space_partition/include/CGAL/Kinetic_space_partition_3.h

@@ -731,7 +731,7 @@ public:
     }
 
     if (m_parameters.verbose)
-    std::cout << "ksp v: " << m_partition_nodes[0].m_data->vertices().size() << " f: " << m_partition_nodes[0].face2vertices.size() << " vol: " << m_volumes.size() << std::endl;
+      std::cout << "ksp v: " << m_partition_nodes[0].m_data->vertices().size() << " f: " << m_partition_nodes[0].face2vertices.size() << " vol: " << m_volumes.size() << std::endl;
 
     return;
   }

Kinetic_surface_reconstruction/doc/Kinetic_surface_reconstruction/Kinetic_surface_reconstruction.txt

@@ -284,9 +284,9 @@ Building_C
 <TD class="math" ALIGN=RIGHT NOWRAP>
 3.432
 <TD class="math" ALIGN=RIGHT NOWRAP>
-370
+369
 <TD class="math" ALIGN=RIGHT NOWRAP>
-1.466
+1.457
 <TD class="math" ALIGN=RIGHT NOWRAP>
 40,1
 <TD class="math" ALIGN=RIGHT NOWRAP>
@@ -376,10 +376,10 @@ Meeting Room
 <TD class="math" ALIGN=RIGHT NOWRAP>
 15
 <TD class="math" ALIGN=RIGHT NOWRAP>
-0,03
-<TD class="math" ALIGN=RIGHT NOWRAP>
 10
 <TD class="math" ALIGN=RIGHT NOWRAP>
+0,03
+<TD class="math" ALIGN=RIGHT NOWRAP>
 3
 <TD class="math" ALIGN=RIGHT NOWRAP>
 0,5
@@ -396,10 +396,10 @@ Full Thing
 <TD class="math" ALIGN=RIGHT NOWRAP>
 12
 <TD class="math" ALIGN=RIGHT NOWRAP>
-0,05
-<TD class="math" ALIGN=RIGHT NOWRAP>
 3
 <TD class="math" ALIGN=RIGHT NOWRAP>
+0,05
+<TD class="math" ALIGN=RIGHT NOWRAP>
 1
 <TD class="math" ALIGN=RIGHT NOWRAP>
 0,5
@@ -416,10 +416,10 @@ Hilbert cube
 <TD class="math" ALIGN=RIGHT NOWRAP>
 12
 <TD class="math" ALIGN=RIGHT NOWRAP>
-0,03
-<TD class="math" ALIGN=RIGHT NOWRAP>
 5
 <TD class="math" ALIGN=RIGHT NOWRAP>
+0,03
+<TD class="math" ALIGN=RIGHT NOWRAP>
 4
 <TD class="math" ALIGN=RIGHT NOWRAP>
 0,5
@@ -456,10 +456,10 @@ Building_C
 <TD class="math" ALIGN=RIGHT NOWRAP>
 15
 <TD class="math" ALIGN=RIGHT NOWRAP>
-0,5
-<TD class="math" ALIGN=RIGHT NOWRAP>
 3
 <TD class="math" ALIGN=RIGHT NOWRAP>
+0,5
+<TD class="math" ALIGN=RIGHT NOWRAP>
 2
 <TD class="math" ALIGN=RIGHT NOWRAP>
 0,77

Kinetic_surface_reconstruction/examples/Kinetic_surface_reconstruction/ksr_parameters.cpp

@@ -171,15 +171,10 @@ int main(const int argc, const char** argv) {
   timer.start();
   std::size_t num_shapes = ksr.detect_planar_shapes(param);
 
-
+  std::cout << num_shapes << " regularized detected planar shapes" << std::endl;
-  std::cout << num_shapes << " detected planar shapes" << std::endl;
 
   FT after_shape_detection = timer.time();
 
-  ksr.initialize_partition(param);
-
-  FT after_init = timer.time();
-
   ksr.partition(parameters.k_intersections);
 
   FT after_partition = timer.time();
@@ -198,6 +193,8 @@ int main(const int argc, const char** argv) {
 
   FT after_reconstruction = timer.time();
 
+  std::cout << polylist.size() << " polygons, " << vtx.size() << " vertices" << std::endl;
+
   if (polylist.size() > 0)
     CGAL::IO::write_polygon_soup("polylist_" + std::to_string(parameters.graphcut_lambda) + (parameters.use_ground ? "_g" : "_") + ".off", vtx, polylist);
 
@@ -220,19 +217,16 @@ int main(const int argc, const char** argv) {
     else
       ksr.reconstruct(l, external_nodes, std::back_inserter(vtx), std::back_inserter(polylist));
 
-
     if (polylist.size() > 0) {
       non_empty = true;
       CGAL::IO::write_polygon_soup("polylist_" + std::to_string(l) + (parameters.use_ground ? "_g" : "_") + ".off", vtx, polylist);
     }
   }
 
-  std::cout << "Shape detection:        " << after_shape_detection << " seconds!" << std::endl;
+  std::cout << "Shape detection and initialization\nof kinetic partition:     " << after_shape_detection << " seconds!" << std::endl;
-  std::cout << "Kinetic partition:      " << (after_partition - after_shape_detection) << " seconds!" << std::endl;
+  std::cout << "Kinetic partition:        " << (after_partition - after_shape_detection) << " seconds!" << std::endl;
-  std::cout << " initialization:        " << (after_init - after_shape_detection) << " seconds!" << std::endl;
+  std::cout << "Kinetic reconstruction:   " << (after_reconstruction - after_partition) << " seconds!" << std::endl;
-  std::cout << " partition:             " << (after_partition - after_init) << " seconds!" << std::endl;
+  std::cout << "Total time:               " << time << " seconds!" << std::endl << std::endl;
-  std::cout << "Kinetic reconstruction: " << (after_reconstruction - after_partition) << " seconds!" << std::endl;
-  std::cout << "Total time:             " << time << " seconds!" << std::endl << std::endl;
 
   return (non_empty) ? EXIT_SUCCESS : EXIT_FAILURE;
 }

Kinetic_surface_reconstruction/include/CGAL/Kinetic_surface_reconstruction_3.h

@@ -627,7 +627,6 @@ private:
   std::vector<std::pair<std::size_t, std::size_t> > m_volume_votes; // pair<inside, outside> votes
   std::vector<bool> m_volume_below_ground;
   std::vector<std::vector<double> > m_cost_matrix;
-  std::vector<FT> m_volumes; // normalized volume of each kinetic volume
   std::vector<std::size_t> m_labels;
 
   std::size_t m_total_inliers;
@@ -747,9 +746,9 @@ private:
       std::cout << "* computing data term ... ";
 
     std::size_t max_inside = 0, max_outside = 0;
-    for (std::size_t i = 0; i < m_volumes.size(); i++) {
+    for (std::size_t i = 6; i < m_cost_matrix[0].size(); i++) {
-      max_inside = (std::max<std::size_t>)(static_cast<std::size_t>(m_cost_matrix[0][i + 6]), max_inside);
+      max_inside = (std::max<std::size_t>)(static_cast<std::size_t>(m_cost_matrix[0][i]), max_inside);
-      max_outside = (std::max<std::size_t>)(static_cast<std::size_t>(m_cost_matrix[1][i + 6]), max_outside);
+      max_outside = (std::max<std::size_t>)(static_cast<std::size_t>(m_cost_matrix[1][i]), max_outside);
     }
 
     // Dump volumes colored by votes
@@ -1743,55 +1742,14 @@ private:
     return face_area;
   }
 
-  FT volume(typename LCC::Dart_descriptor volume_dart) {
-    FT x = 0, y = 0, z = 0;
-    std::size_t count = 0;
-    From_exact from_exact;
-
-    // Collect vertices to obtain point on the inside.
-    for (auto& fd : m_lcc.template one_dart_per_incident_cell<2, 3>(volume_dart)) {
-      typename LCC::Dart_descriptor fdh = m_lcc.dart_descriptor(fd);
-
-      for (const auto& vd : m_lcc.template one_dart_per_incident_cell<0, 2>(fdh)) {
-        const auto &p = from_exact(m_lcc.point(m_lcc.dart_descriptor(vd)));
-        x += p.x();
-        y += p.y();
-        z += p.z();
-        count++;
-      }
-    }
-
-    Point_3 center(x / count, y / count, z / count);
-
-    FT vol = 0;
-    // Second iteration for computing the area of each face and the volume spanned with the center point.
-    for (auto& fd : m_lcc.template one_dart_per_incident_cell<2, 3>(volume_dart)) {
-      typename LCC::Dart_descriptor fdh = m_lcc.dart_descriptor(fd);
-
-      Plane_3 plane;
-      FT a = area(fdh, plane);
-      Vector_3 n = plane.orthogonal_vector();
-
-      FT distance = CGAL::abs((plane.point() - center) * n);
-      vol += distance * a / 3.0;
-    }
-
-    return vol;
-  }
-
   void count_volume_votes_lcc() {
 //    const int debug_volume = -1;
-    FT total_volume = 0;
     std::size_t num_volumes = m_kinetic_partition.number_of_volumes();
     m_volume_votes.clear();
     m_volume_votes.resize(num_volumes, std::make_pair(0, 0));
 
-    m_volumes.resize(num_volumes, 0);
+    for (std::size_t i = 6; i < num_volumes; i++)
-
-    for (std::size_t i = 6; i < num_volumes; i++) {
       m_cost_matrix[0][i] = m_cost_matrix[1][i] = 0;
-      m_volumes[i] = 0;
-    }
 
     From_exact from_exact;
 
@@ -1829,28 +1787,15 @@ private:
         m_cost_matrix[1][v[j] + 6] += static_cast<double>(out[j]);
       }
     }
-
-    for (auto& d : m_lcc.template one_dart_per_cell<3>()) {
-      typename LCC::Dart_descriptor dh = m_lcc.dart_descriptor(d);
-
-      std::size_t volume_index = m_lcc.template info<3>(dh).volume_id;
-      m_volumes[volume_index] = volume(dh);
-
-      total_volume += m_volumes[volume_index];
-    }
-
-    // Normalize volumes
-    for (FT& v : m_volumes)
-      v /= total_volume;
   }
 
   template<typename NamedParameters>
   void create_planar_shapes(const NamedParameters& np) {
-
     if (m_points.size() < 3) {
       if (m_verbose) std::cout << "* no points found, skipping" << std::endl;
       return;
     }
+
     if (m_verbose) std::cout << "* getting planar shapes using region growing" << std::endl;
 
     FT xmin, ymin, zmin, xmax, ymax, zmax;