Adding 3D barycentric coordinates for convex polyhedra

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;
+}