// Copyright (c) 2020 GeometryFactory (France) and Telecom Paris (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL: https://github.com/CGAL/cgal/blob/v5.1/Tetrahedral_remeshing/include/CGAL/tetrahedral_remeshing.h $
// $Id: tetrahedral_remeshing.h 962b681 2020-07-31T15:52:56+02:00 Laurent Rineau
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s)     : Jane Tournois, Noura Faraj, Jean-Marc Thiery, Tamy Boubekeur

#ifndef TETRAHEDRAL_REMESHING_H
#define TETRAHEDRAL_REMESHING_H

#include <CGAL/license/Tetrahedral_remeshing.h>

#include <CGAL/Triangulation_3.h>
#include <CGAL/Mesh_complex_3_in_triangulation_3.h>

#include <CGAL/Tetrahedral_remeshing/Sizing_field.h>
#include <CGAL/Tetrahedral_remeshing/Uniform_sizing_field.h>
#include <CGAL/Tetrahedral_remeshing/internal/tetrahedral_adaptive_remeshing_impl.h>
#include <CGAL/Tetrahedral_remeshing/internal/compute_c3t3_statistics.h>

#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>

#ifdef CGAL_DUMP_REMESHING_STEPS
#include <sstream>
#endif

namespace CGAL
{
///////////////////////////////////////////////////
///////////////// TRIANGULATION_3 /////////////////
///////////////////////////////////////////////////
/*!
* \ingroup PkgTetrahedralRemeshingRef
* remeshes a tetrahedral mesh.
*
* It is recommended to use `CGAL::Tetrahedral_remeshing::Remeshing_triangulation_3`
* for the first parameter, as it inherits from `Triangulation_3` with a `TDS` suitable for this function.
*
* This function takes as input a 3-dimensional triangulation
* and performs a sequence of atomic operations
* in order to generate as output a high quality mesh with a prescribed
* uniform density.
* These atomic operations are performed as follows:
*   - edge splits, until all edges satisfy a prescribed length criterion,
*   - edge collapses, until all edges satisfy a prescribed length criterion,
*   - edge flips, to locally improve dihedral angles, until they can
*     no longer be improved by flipping,
*   - global smoothing by vertex relocations,
*   - re-projection of boundary vertices to the initial surface.
*
* This remeshing function can deal with multi-domains, boundaries, and features.
* It preserves the geometry of
* subdomains throughout the remeshing process.
*
* Subdomains are defined by indices that
* are stored in the cells of the input triangulation, following the `MeshCellBase_3`
* concept (refined by `RemeshingCellBase_3`).
* The surfacic interfaces between subdomains are formed by facets whose two incident cells
* have different subdomain indices.
* The edges where three or more subdomains meet form feature polylines,
* and are considered as constrained edges.
*
*
* @tparam Traits is the geometric traits, model of `RemeshingTriangulationTraits_3`
* @tparam TDS is the triangulation data structure for `Triangulation_3`,
*             model of ` TriangulationDataStructure_3`,
*             with cell base model of `RemeshingCellBase_3`
*             and vertex base model of `RemeshingVertexBase_3`.
* @tparam SLDS is an optional parameter for `Triangulation_3`, that
*             specifies the type of the spatial lock data structure.
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param tr the triangulation to be remeshed, of type `Triangulation_3<Traits, TDS, SLDS>`.
*           `Remeshing_triangulation` is a helper class that satisfies all the requirements
*           of its template parameters.
* @param target_edge_length the uniform target edge length. This parameter provides a
*          mesh density target for the remeshing algorithm.
* @param np optional sequence of \ref bgl_namedparameters "Named Parameters"
*          among the ones listed below
*
* \cgalNamedParamsBegin
*   \cgalParamNBegin{number_of_iterations}
*     \cgalParamDescription{the number of iterations for the full sequence of atomic operations
*                           performed (listed in the above description)}
*     \cgalParamType{unsigned int}
*     \cgalParamDefault{`1`}
*   \cgalParamNEnd
*
*   \cgalParamNBegin{remesh_boundaries}
*     \cgalParamDescription{If `false`, none of the input volume boundaries can be modified.
*                           Otherwise, the topology is preserved, but atomic operations
*                           can be performed on the surfaces, and along feature polylines,
*                           such that boundaries are remeshed.}
*     \cgalParamType{`bool`}
*     \cgalParamDefault{`true`}
*     \cgalParamExtra{Boundaries are between the exterior and the interior,
*                     between two subdomains, between the areas selected or not for remeshing
*                     (cf `Remeshing_cell_is_selected_map`), or defined
*                     by `Remeshing_edge_is_constrained_map` and `Remeshing_facet_is_constrained_map`.}
*   \cgalParamNEnd
*
*   \cgalParamNBegin{edge_is_constrained_map}
*     \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tr`.}
*     \cgalParamType{a class model of `ReadWritePropertyMap` with `std::pair<Triangulation_3::Vertex_handle, Triangulation_3::Vertex_handle>`
*                    as key type and `bool` as value type. It must be default constructible.}
*     \cgalParamDefault{a default property map where no edge is constrained}
*     \cgalParamExtra{A constrained edge can be split or collapsed, but not flipped.}
*     \cgalParamExtra{The pairs must be ordered to ensure consistency.}
*     \cgalParamExtra{During the meshing process, the set of constrained edges evolves consistently
*                     with edge splits and collapses, so the property map must be writable.}
*   \cgalParamNEnd
*
*   \cgalParamNBegin{facet_is_constrained_map}
*     \cgalParamDescription{a property map containing the constrained-or-not status of each facet of `tr`.}
*     \cgalParamType{a class model of `ReadablePropertyMap` with `Triangulation_3::Facet`
*                    as key type and `bool` as value type. It must be default constructible.}
*     \cgalParamDefault{a default property map where no facet is constrained}
*     \cgalParamExtra{A constrained facet can be split or collapsed, but not flipped.}
*     \cgalParamExtra{This map, contrary to the others, is not updated throughout the remeshing process.}
*   \cgalParamNEnd
*
*   \cgalParamNBegin{cell_is_selected_map}
*     \cgalParamDescription{a property map containing the selected - or - not status for each cell of `tr` for remeshing.
*                           Only selected cells are modified (and possibly their neighbors if surfaces are modified) by remeshing.}
*     \cgalParamType{a class model of `ReadWritePropertyMap` with `Triangulation_3::Cell_handle`
*                    as key type and `bool` as value type. It must be default constructible.}
*     \cgalParamDefault{a default property map where all cells of the domain
*                       (i.e. with a non-zero `Subdomain_index`) are selected.}
*     \cgalParamExtra{During the meshing process, the set of selected cells evolves consistently with
*                     the atomic operations that are performed, so the property map must be writable.}
*   \cgalParamNEnd
*
*   \cgalParamNBegin{smooth_constrained_edges}
*     \cgalParamDescription{If `true`, the end vertices of the edges set as
*                           constrained in `edge_is_constrained_map` move along the
*                           constrained polylines they belong to.}
*     \cgalParamType{`bool`}
*     \cgalParamDefault{`false`}
*     \cgalParamExtra{The endvertices of constraints listed
*                     by `edge_is_constrained_map`, and edges incident to at least three subdomains
*                     are made eligible to one dimensional smoothing, along the constrained polylines they belong to.
*                     Corners (i.e. vertices incident to more than 2 constrained edges) are not allowed
*                     to move at all.\n
*                     Note that activating the smoothing step on polyline constraints tends to reduce
*                     the quality of the minimal dihedral angle in the mesh.\n
*                     If `remesh_boundaries` is set to `false`, this parameter is ignored.}
*   \cgalParamNEnd
*
*  \cgalNamedParamsEnd
*
* \sa `CGAL::Tetrahedral_remeshing::Remeshing_triangulation_3`
*
* @todo implement non-uniform sizing field instead of uniform target edge length
*/
template<typename Traits, typename TDS, typename SLDS,
         typename NamedParameters>
void tetrahedral_isotropic_remeshing(
  CGAL::Triangulation_3<Traits, TDS, SLDS>& tr,
  const double& target_edge_length,
  const NamedParameters& np)
{
  typedef CGAL::Triangulation_3<Traits, TDS, SLDS> Triangulation;
  tetrahedral_isotropic_remeshing(
    tr,
    [target_edge_length](const typename Triangulation::Point& /* p */)
                        {return target_edge_length;},
    np);
}

template<typename Traits, typename TDS, typename SLDS,
         typename NamedParameters>
void tetrahedral_isotropic_remeshing(
  CGAL::Triangulation_3<Traits, TDS, SLDS>& tr,
  const float& target_edge_length,
  const NamedParameters& np)
{
  typedef CGAL::Triangulation_3<Traits, TDS, SLDS> Triangulation;
  tetrahedral_isotropic_remeshing(
    tr,
    [target_edge_length](const typename Triangulation::Point& /* p */)
                        {return target_edge_length; },
    np);
}

template<typename Traits, typename TDS, typename SLDS,
         typename SizingFunction,
         typename NamedParameters>
void tetrahedral_isotropic_remeshing(
  CGAL::Triangulation_3<Traits, TDS, SLDS>& tr,
  const SizingFunction& sizing,
  const NamedParameters& np)
{
  CGAL_assertion(tr.is_valid(true));

  typedef CGAL::Triangulation_3<Traits, TDS, SLDS> Tr;

  using parameters::choose_parameter;
  using parameters::get_parameter;

  bool remesh_surfaces = choose_parameter(get_parameter(np, internal_np::remesh_boundaries),
                                          true);
  bool protect = !remesh_surfaces;
  // bool adaptive = choose_parameter(get_parameter(np, internal_np::adaptive_size),
  //                              false);
  std::size_t max_it = choose_parameter(get_parameter(np, internal_np::number_of_iterations),
                                        1);
  bool smooth_constrained_edges
    = choose_parameter(get_parameter(np, internal_np::smooth_constrained_edges),
                       false);

  typedef typename internal_np::Lookup_named_param_def <
    internal_np::cell_selector_t,
    NamedParameters,
    Tetrahedral_remeshing::internal::All_cells_selected<Tr>//default
  > ::type SelectionFunctor;
  SelectionFunctor cell_select
    = choose_parameter(get_parameter(np, internal_np::cell_selector),
                       Tetrahedral_remeshing::internal::All_cells_selected<Tr>());

  typedef std::pair<typename Tr::Vertex_handle, typename Tr::Vertex_handle> Edge_vv;
  typedef Tetrahedral_remeshing::internal::No_constraint_pmap<Edge_vv> No_edge;
  typedef typename internal_np::Lookup_named_param_def <
    internal_np::edge_is_constrained_t,
    NamedParameters,
    No_edge//default
  > ::type ECMap;
  ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
                                 No_edge());

  typedef typename Tr::Facet Facet;
  typedef Tetrahedral_remeshing::internal::No_constraint_pmap<Facet> No_facet;
  typedef typename internal_np::Lookup_named_param_def <
    internal_np::facet_is_constrained_t,
    NamedParameters,
    No_facet//default
  > ::type FCMap;
  FCMap fcmap = choose_parameter(get_parameter(np, internal_np::facet_is_constrained),
                                 No_facet());

  typedef typename internal_np::Lookup_named_param_def <
    internal_np::remeshing_visitor_t,
    NamedParameters,
    Tetrahedral_remeshing::internal::Default_remeshing_visitor
  > ::type Visitor;
  Visitor visitor
    = choose_parameter(get_parameter(np, internal_np::remeshing_visitor),
                       Tetrahedral_remeshing::internal::Default_remeshing_visitor());

#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  std::cout << "Tetrahedral remeshing ("
            << "nb_iter = " << max_it << ", "
            << "protect = " << std::boolalpha << protect
            << ")" << std::endl;

  std::cout << "Init tetrahedral remeshing...";
  std::cout.flush();
#endif

  typedef Tetrahedral_remeshing::internal::Adaptive_remesher<
    Tr, SizingFunction, ECMap, FCMap, SelectionFunctor, Visitor> Remesher;
  Remesher remesher(tr, sizing, protect
                  , ecmap, fcmap
                  , smooth_constrained_edges
                  , cell_select
                  , visitor);

#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  std::cout << "done." << std::endl;
  Tetrahedral_remeshing::internal::compute_statistics(
    remesher.tr(), cell_select, "statistics_begin.txt");
#endif

  // perform remeshing
  std::size_t nb_extra_iterations = 3;
  remesher.remesh(max_it, nb_extra_iterations);

#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  const double angle_bound = 5.0;
  Tetrahedral_remeshing::debug::dump_cells_with_small_dihedral_angle(tr,
    angle_bound, cell_select, "bad_cells.mesh");
  Tetrahedral_remeshing::internal::compute_statistics(tr,
    cell_select, "statistics_end.txt");
#endif
}

template<typename Traits, typename TDS, typename SLDS>
void tetrahedral_isotropic_remeshing(
  CGAL::Triangulation_3<Traits, TDS, SLDS>& tr,
  const double& target_edge_length)
{
  tetrahedral_isotropic_remeshing(tr, target_edge_length,
                                 CGAL::parameters::all_default());
}

/*!
* \ingroup PkgTetrahedralRemeshingRef
* converts the triangulation contained in the input to a `Triangulation_3`.
*
* This function should be used to generate a valid triangulation
* for tetrahedral remeshing, when the input triangulation is generated with the
* tetrahedral mesh generation package.
*
* @tparam Tr is the underlying triangulation for `Mesh_complex_3_in_triangulation_3`.
*            It can be instantiated with any 3D regular triangulation of CGAL provided
*            that its vertex and cell base classes are models of the concepts
*            `MeshVertexBase_3` (refined by `RemeshingCellBase_3`)
*            and `MeshCellBase_3` (refined by `RemeshingVertexBase_3`), respectively.
* @tparam CornerIndex is the type of the indices for feature corners.
*            If `c3t3` has been generated using `CGAL::make_mesh_3()`, it must match
*            the `Corner_index` type of the model of the `MeshDomainWithFeatures_3` concept used for mesh generation.
* @tparam CurveIndex is the type of the indices for feature curves.
*            If `c3t3` has been generated using `CGAL::make_mesh_3()`, it must match
*            the `Curve_index` type of the model of the `MeshDomainWithFeatures_3` concept used for mesh generation.
*
* @param c3t3 the complex containing the triangulation to be remeshed.
*/

template<typename Tr,
         typename CornerIndex,
         typename CurveIndex>
CGAL::Triangulation_3<typename Tr::Geom_traits,
                      typename Tr::Triangulation_data_structure>
convert_to_triangulation_3(
  CGAL::Mesh_complex_3_in_triangulation_3<Tr, CornerIndex, CurveIndex> c3t3)
{
  using GT   = typename Tr::Geom_traits;
  using TDS  = typename Tr::Triangulation_data_structure;

  CGAL::Triangulation_3<GT, TDS> tr;
  tr.swap(c3t3.triangulation());
  return tr;
}

///////////////////////////////////////////////////
/////// MESH_COMPLEX_3_IN_TRIANGULATION_3 /////////
///////////////////////////////////////////////////

///////
////// Warning with using this version :
////// the triangulation after remeshing is not regular anymore
////// the empty-sphere property is not respected
///////
template<typename Tr,
         typename CornerIndex, typename CurveIndex,
         typename NamedParameters>
void tetrahedral_isotropic_remeshing(
  CGAL::Mesh_complex_3_in_triangulation_3<Tr, CornerIndex, CurveIndex>& c3t3,
  const double& target_edge_length,
  const NamedParameters& np)
{
  tetrahedral_isotropic_remeshing(
    c3t3,
    [target_edge_length](const typename Tr::Point& /* p */)
                        {return target_edge_length; },
    np);
}

template<typename Tr,
         typename CornerIndex, typename CurveIndex,
         typename NamedParameters>
void tetrahedral_isotropic_remeshing(
  CGAL::Mesh_complex_3_in_triangulation_3<Tr, CornerIndex, CurveIndex>& c3t3,
  const float& target_edge_length,
  const NamedParameters& np)
{
  tetrahedral_isotropic_remeshing(
    c3t3,
    [target_edge_length](const typename Tr::Point& /*p*/)
                        {return target_edge_length; },
    np);
}

template<typename Tr,
         typename CornerIndex, typename CurveIndex>
void tetrahedral_isotropic_remeshing(
  CGAL::Mesh_complex_3_in_triangulation_3<Tr, CornerIndex, CurveIndex>& c3t3,
  const double& target_edge_length)
{
  return tetrahedral_isotropic_remeshing(c3t3, target_edge_length,
                                        CGAL::parameters::all_default());
}

template<typename Tr,
         typename CornerIndex, typename CurveIndex,
         typename SizingFunction,
         typename NamedParameters>
void tetrahedral_isotropic_remeshing(
  CGAL::Mesh_complex_3_in_triangulation_3<Tr, CornerIndex, CurveIndex>& c3t3,
  const SizingFunction& sizing,
  const NamedParameters& np)
{
  CGAL_assertion(c3t3.triangulation().tds().is_valid(true));

  using parameters::get_parameter;
  using parameters::choose_parameter;

  bool remesh_surfaces = choose_parameter(get_parameter(np, internal_np::remesh_boundaries),
                                          true);
  bool protect = !remesh_surfaces;
  std::size_t max_it = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);

  bool smooth_constrained_edges
    = choose_parameter(get_parameter(np, internal_np::smooth_constrained_edges),
      false);

  typedef typename internal_np::Lookup_named_param_def <
  internal_np::cell_selector_t,
              NamedParameters,
              Tetrahedral_remeshing::internal::All_cells_selected<Tr>//default
              > ::type SelectionFunctor;
  SelectionFunctor cell_select
    = choose_parameter(get_parameter(np, internal_np::cell_selector),
                       Tetrahedral_remeshing::internal::All_cells_selected<Tr>());

  typedef std::pair<typename Tr::Vertex_handle, typename Tr::Vertex_handle> Edge_vv;
  typedef Tetrahedral_remeshing::internal::No_constraint_pmap<Edge_vv> No_edge;
  typedef typename internal_np::Lookup_named_param_def <
  internal_np::edge_is_constrained_t,
              NamedParameters,
              No_edge//default
              > ::type ECMap;
  ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
                                 No_edge());

  typedef typename Tr::Facet Facet;
  typedef Tetrahedral_remeshing::internal::No_constraint_pmap<Facet> No_facet;
  typedef typename internal_np::Lookup_named_param_def <
  internal_np::facet_is_constrained_t,
              NamedParameters,
              No_facet//default
              > ::type FCMap;
  FCMap fcmap = choose_parameter(get_parameter(np, internal_np::facet_is_constrained),
                                 No_facet());

  typedef typename internal_np::Lookup_named_param_def <
  internal_np::remeshing_visitor_t,
              NamedParameters,
              Tetrahedral_remeshing::internal::Default_remeshing_visitor
              > ::type Visitor;
  Visitor visitor
    = choose_parameter(get_parameter(np, internal_np::remeshing_visitor),
                       Tetrahedral_remeshing::internal::Default_remeshing_visitor());

#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  std::cout << "Tetrahedral remeshing ("
            << "nb_iter = " << max_it << ", "
            << "protect = " << std::boolalpha << protect
            << ")" << std::endl;

  std::cout << "Init tetrahedral remeshing...";
  std::cout.flush();
#endif

  typedef Tetrahedral_remeshing::internal::Adaptive_remesher<
  Tr, SizingFunction, ECMap, FCMap, SelectionFunctor,
  Visitor,
  CornerIndex, CurveIndex
  > Remesher;
  Remesher remesher(c3t3, sizing, protect
                    , ecmap, fcmap
                    , smooth_constrained_edges
                    , cell_select
                    , visitor);

#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  std::cout << "done." << std::endl;
  Tetrahedral_remeshing::internal::compute_statistics(
    remesher.tr(),
    cell_select, "statistics_begin.txt");
#endif

  // perform remeshing
  std::size_t nb_extra_iterations = 3;
  remesher.remesh(max_it, nb_extra_iterations);

#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  const double angle_bound = 5.0;
  Tetrahedral_remeshing::debug::dump_cells_with_small_dihedral_angle(
    c3t3.triangulation(),
    angle_bound, cell_select, "bad_cells.mesh");
#endif
#ifdef CGAL_TETRAHEDRAL_REMESHING_VERBOSE
  Tetrahedral_remeshing::internal::compute_statistics(
    c3t3.triangulation(),
    cell_select, "statistics_end.txt");
#endif
}

}//end namespace CGAL

#endif //TETRAHEDRAL_REMESHING_H