Periodic_3_triangulations.hpp

Go to the documentation of this file.

 
#ifndef INCLUDE_PERIODIC_3_TRIANGULATIONS_HPP_
#define INCLUDE_PERIODIC_3_TRIANGULATIONS_HPP_
 
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Periodic_3_Delaunay_triangulation_3.h>
#include <CGAL/Periodic_3_triangulation_filtered_traits_3.h>
#include <CGAL/point_generators_2.h>
#include <CGAL/Random.h>
#include <CGAL/Timer.h>
#include <CGAL/Triangulation_vertex_base_with_info_3.h>
#include <fmt/ostream.h>
 
#include <cassert>
#include <vector>
 
namespace cdt::experimental::periodic_triangulations
{
  using K       = CGAL::Exact_predicates_inexact_constructions_kernel;
  using GT      = CGAL::Periodic_3_triangulation_filtered_traits_3<K>;
 
  using VbDS    = CGAL::Periodic_3_triangulation_ds_vertex_base_3<>;
  using T3Vb    = CGAL::Triangulation_vertex_base_3<GT, VbDS>;
 
  using CbDS    = CGAL::Periodic_3_triangulation_ds_cell_base_3<>;
  using Cb      = CGAL::Triangulation_cell_base_3<GT, CbDS>;

  using VbInfo  = CGAL::Triangulation_vertex_base_with_info_3<int, GT, T3Vb>;
  using TDS     = CGAL::Triangulation_data_structure_3<VbInfo, Cb>;
  using PDT     = CGAL::Periodic_3_Delaunay_triangulation_3<GT, TDS>;
  using T3Point = PDT::Point;

  using Kd      = CGAL::Cartesian_d<double>;
  using Point   = Kd::Point_d;

  template <typename T>
  void make_random_T3_triangulation(T* T3, int simplices, int timeslices)
  {
    fmt::print("make_random_T3_triangulation() called\n");
 
    int simplices_per_timeslice = simplices / timeslices;
    int points                  = simplices / 6;
    int points_per_timeslice    = simplices_per_timeslice / 6;
    int const          dim      = 2;
 
    std::vector<Point> v;
    v.reserve(points);

    double                               size = sqrt(points_per_timeslice);
 
    CGAL::Random_points_in_cube_d<Point> gen(dim, size);

    for (int timeslice_index = 0; timeslice_index < timeslices;
         ++timeslice_index)
    {
      fmt::print("Timeslice {}\n", timeslice_index);
      for (int point_index = 0; point_index < points_per_timeslice;
           ++point_index)
      {
        v.push_back(*gen++);
      }
      for (int point_index = 0; point_index < points_per_timeslice;
           ++point_index)
      {
        auto const offset =
            timeslice_index * points_per_timeslice + point_index;
        fmt::print(" {}\n", fmt::streamed(v[static_cast<std::size_t>(offset)]));
      }
    }
  }
}  // namespace cdt::experimental::periodic_triangulations
#endif  // INCLUDE_PERIODIC_3_TRIANGULATIONS_HPP_