Adding 3D barycentric coordinates for convex polyhedra

Barycentric_coordinates_2/include/CGAL/Barycentric_coordinates_2/Generalized_barycentric_coordinates_2.h

@@ -387,23 +387,18 @@ Generalized_barycentric_coordinates_2
         else {
             // Otherwise, all the coordinates are zero apart from those for the chosen edge with the index = `index`.
             for(int i = 0; i < index; ++i) {
-                *output = FT(0);
-                ++output;
+                *output++ = FT(0);
             }
 
             // Compute segment coordinates along the chosen edge with the index = `index`.
-            Segment_coordinates_2<Traits> segment_coordinates(vertex[index], vertex[index+1]);
-            std::optional<OutputIterator> success = segment_coordinates(query_point, output);
-            ++output;
+            output = segment_coordinates_2(vertex[index], vertex[index+1], query_point, output);
 
             for(int i = index + 1; i < last; ++i) {
-                *output = FT(0);
-                ++output;
+                *output++ = FT(0);
             }
 
             // Return coordinates.
-            if(success) return std::optional<OutputIterator>(output);
-            else return std::optional<OutputIterator>();
+            return output;
         }
 
         // Pointer cannot be here. Something went wrong.
@@ -429,31 +424,24 @@ Generalized_barycentric_coordinates_2
         else {
             // Otherwise, all the coordinates are zeros apart from those for the edge with the query point.
             int index;
-            bool status = false;
             for(index = 0; index < last; ++index) {
                 if(collinear_2(vertex[index], vertex[index+1], query_point) && collinear_are_ordered_along_line_2(vertex[index], query_point, vertex[index+1])) {
 
                     // Compute segment coordinates along the edge with the query point.
-                    Segment_coordinates_2<Traits> segment_coordinates(vertex[index], vertex[index+1]);
-                    std::optional<OutputIterator> success = segment_coordinates(query_point, output);
-                    if(success) status = true;
-                    ++output;
+                    output = segment_coordinates_2(vertex[index], vertex[index+1], query_point, output);
                     break;
 
                 } else {
-                    *output = FT(0);
-                    ++output;
+                    *output++ = FT(0);
                 }
             }
 
             for(int i = index + 1; i < last; ++i) {
-                *output = FT(0);
-                ++output;
+                *output++ = FT(0);
             }
 
             // Return coordinates.
-            if(status == true) return std::optional<OutputIterator>(output);
-            else return std::optional<OutputIterator>();
+            return output;
         }
 
         // Pointer cannot be here. Something went wrong.
@@ -478,22 +466,18 @@ Generalized_barycentric_coordinates_2
 
         // Compute segment coordinates along the last edge of the polygon.
         Segment_coordinates_2<Traits> segment_coordinates(vertex[last], vertex[0]);
-        std::optional<Vector_insert_iterator> success = segment_coordinates(query_point, std::back_inserter(coordinate));
+        segment_coordinates_2(vertex[last], vertex[0], query_point, std::back_inserter(coordinate));
 
         // Store all the coordinate values.
         // All the values are zeros apart from those corresponding to the first and the last vertices of the polygon.
-        *output = coordinate[1];
-        ++output;
+        *output++ = coordinate[1];
         for(int i = 1; i < last; ++i) {
-            *output = FT(0);
-            ++output;
+            *output++ = FT(0);
         }
-        *output = coordinate[0];
-        ++output;
+        *output++ = coordinate[0];
 
         // Return computed coordinates.
-        if(success) return std::optional<OutputIterator>(output);
-        else return std::optional<OutputIterator>();
+        return output;
     }
 
     // COORDINATES AT VERTEX.

Barycentric_coordinates_3/benchmark/Barycentric_coordinates_3/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Created by the script cgal_create_cmake_script.
+# This is the CMake script for compiling a CGAL application.
+
+project(Barycentric_coordinates_3_Examples)
+set(CMAKE_CXX_FLAGS "${CMAXE_CXX_FLAGS} -Wall -Wextra -Werror")
+
+cmake_minimum_required(VERSION 3.1...3.15)
+set(CMAKE_CXX_STANDARD 14)
+
+find_package(CGAL QUIET COMPONENTS Core)
+if(CGAL_FOUND)
+
+  include(${CGAL_USE_FILE})
+  include(CGAL_CreateSingleSourceCGALProgram)
+
+  create_single_source_cgal_program("benchmark_tetrahedon_coordinates.cpp")
+  create_single_source_cgal_program("benchmark_polyhedron_8_vertices.cpp")
+
+else()
+  message(WARNING "This program requires the CGAL library, and will not be compiled.")
+endif()

Barycentric_coordinates_3/benchmark/Barycentric_coordinates_3/benchmark_polyhedron_8_vertices.cpp

@@ -0,0 +1,102 @@
+#include <CGAL/Real_timer.h>
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Barycentric_coordinates_3/Wachspress_coordinates_3.h>
+#include <CGAL/Barycentric_coordinates_3/Mean_value_coordinates_3.h>
+#include <CGAL/Barycentric_coordinates_3/Discrete_harmonic_coordinates_3.h>
+
+#include <CGAL/Surface_mesh.h>
+#include <CGAL/Polygon_mesh_processing/triangulate_faces.h>
+
+#include <fstream>
+
+using Kernel = CGAL::Exact_predicates_inexact_constructions_kernel;
+using FT = typename Kernel::FT;
+using Point_3 = typename Kernel::Point_3;
+using Timer = CGAL::Real_timer;
+using Vertices = std::vector<Point_3>;
+using SM = CGAL::Surface_mesh<Point_3>;
+
+using WPC3 = CGAL::Barycentric_coordinates::Wachspress_coordinates_3<SM, Kernel>;
+using MVC3 = CGAL::Barycentric_coordinates::Mean_value_coordinates_3<SM, Kernel>;
+using DHC3 = CGAL::Barycentric_coordinates::Discrete_harmonic_coordinates_3<SM, Kernel>;
+
+template<typename COORD>
+double benchmark_overload(const FT scale){
+
+  const std::size_t number_of_runs = 10;
+
+  // Cube
+  SM cube;
+  Vertices cube_coords;
+
+  cube_coords = {Point_3(1.0, 0.0, 0.0), Point_3(1.0, 1.0, 0.0),
+                Point_3(0.0, 1.0, 0.0), Point_3(0.0, 0.0, 0.0),
+                Point_3(0.0, 0.0, 1.0), Point_3(1.0, 0.0, 1.0),
+                Point_3(1.0, 1.0, 1.0), Point_3(0.0, 1.0, 1.0)};
+
+  CGAL::make_hexahedron(cube_coords[0], cube_coords[1], cube_coords[2], cube_coords[3],
+                        cube_coords[4], cube_coords[5], cube_coords[6], cube_coords[7], cube);
+
+  CGAL::Polygon_mesh_processing::triangulate_faces(cube);
+
+  COORD bar_cube(cube);
+
+  const FT step  = FT(1) / scale;
+  const FT limit = step*scale;
+
+  std::vector<FT> bar_coordinates_cube;
+  bar_coordinates_cube.resize(8);
+
+  Timer timer;
+  double time = 0.0;
+
+  // Sample interior points
+  for(std::size_t i = 0; i < number_of_runs; i++){
+
+    timer.start();
+    for(FT x = step; x < limit - step; x += step){
+      for(FT y = step; y < limit - step; y += step){
+        for(FT z = step; z < limit - step; z += step){
+
+          const Point_3 query(x, y, z);
+          bar_cube(query, bar_coordinates_cube.begin());
+        }
+      }
+    }
+    timer.stop();
+    time += timer.time();
+    timer.reset();
+  }
+
+  const double mean_time =
+    time / static_cast<double>(number_of_runs);
+
+  return mean_time;
+}
+
+int main(){
+
+  std::ofstream wp_file("wp_bench.txt");
+  std::ofstream dh_file("dh_bench.txt");
+  std::ofstream mv_file("mv_bench.txt");
+
+  std::ofstream num_file("num_bench.txt");
+
+  for(std::size_t i = 5; i <= 100; i += 5){
+
+    wp_file << benchmark_overload<WPC3>(i) << std::endl;
+    dh_file << benchmark_overload<DHC3>(i) << std::endl;
+    mv_file << benchmark_overload<MVC3>(i) << std::endl;
+
+    num_file << i << std::endl;
+
+    std::cout << i << "\% complete" << std::endl;
+  }
+
+  wp_file.close();
+  dh_file.close();
+  mv_file.close();
+  num_file.close();
+
+  return EXIT_SUCCESS;
+}

Barycentric_coordinates_3/benchmark/Barycentric_coordinates_3/benchmark_tetrahedon_coordinates.cpp

@@ -0,0 +1,61 @@
+#include <CGAL/Real_timer.h>
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Barycentric_coordinates_3/tetrahedron_coordinates.h>
+
+using Kernel = CGAL::Exact_predicates_inexact_constructions_kernel;
+using FT = typename Kernel::FT;
+using Point_3 = typename Kernel::Point_3;
+using Timer = CGAL::Real_timer;
+
+int main() {
+
+  const std::size_t number_of_x_coordinates = 100;
+  const std::size_t number_of_y_coordinates = 100;
+  const std::size_t number_of_z_coordinates = 100;
+
+  const std::size_t number_of_runs = 10;
+
+  const FT zero = FT(0);
+  const FT one = FT(1);
+  const FT four = FT(4);
+
+  const FT x_step = one / static_cast<FT>(number_of_x_coordinates);
+  const FT y_step = one / static_cast<FT>(number_of_y_coordinates);
+  const FT z_step = one / static_cast<FT>(number_of_z_coordinates);
+
+  const Point_3 p0 = Point_3(zero - x_step, zero - y_step, zero - z_step);
+  const Point_3 p1 = Point_3(four + x_step, zero - y_step, zero - z_step);
+  const Point_3 p2 = Point_3(zero - x_step, four + y_step, zero - z_step);
+  const Point_3 p3 = Point_3(zero - x_step, zero - y_step, four + z_step);
+
+  Timer timer;
+  std::vector<FT> coordinates(4);
+  double time = 0.0;
+
+  for(std::size_t i = 0; i < number_of_runs; i++){
+
+    timer.start();
+    for (FT x = zero; x <= one; x += x_step){
+      for (FT y = zero; y <= one; y += y_step){
+        for (FT z = zero; z <= one; z += z_step){
+
+          const Point_3 query(x, y, z);
+          CGAL::Barycentric_coordinates::tetrahedron_coordinates(
+            p0, p1, p2, p3, query, coordinates.begin());
+        }
+      }
+    }
+
+    timer.stop();
+    time += timer.time();
+    timer.reset();
+  }
+
+  const double mean_time =
+    time / static_cast<double>(number_of_runs);
+
+  std::cout.precision(10);
+  std::cout << "benchmark_tretrahedron_coordinates (CPU time): " <<
+    mean_time << " seconds" << std::endl;
+  return EXIT_SUCCESS;
+}