songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add missing license include directives

This commit is contained in:
Sébastien Loriot 2024-01-04 11:53:18 +01:00
parent 3564fd1851
commit 241e1bf557
29 changed files with 158 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Bounding_volumes/include/CGAL/Approximate_min_ellipsoid_d/Approximate_min_ellipsoid_d_impl.h
View File

@ -10,6 +10,10 @@
//
// Author(s) : Kaspar Fischer <fischerk@inf.ethz.ch>
#ifndef CGAL_APPROXIMATE_MIN_ELLIPSOID_D_APPROXIMATE_MIN_ELLIPSOID_D_IMPL_H
#define CGAL_APPROXIMATE_MIN_ELLIPSOID_D_APPROXIMATE_MIN_ELLIPSOID_D_IMPL_H
#include <CGAL/license/Bounding_volumes.h>
#include <CGAL/Default_diagonalize_traits.h>
@ -272,3 +276,5 @@ namespace CGAL {
}
}
#endif //CGAL_APPROXIMATE_MIN_ELLIPSOID_D_APPROXIMATE_MIN_ELLIPSOID_D_IMPL_H

7
Bounding_volumes/include/CGAL/Approximate_min_ellipsoid_d/Khachiyan_approximation_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Kaspar Fischer <fischerk@inf.ethz.ch>
#ifndef CGAL_APPROX_MIN_ELLIPSOID_KHACHIYAN_APPROX_IMPL_H
#define CGAL_APPROX_MIN_ELLIPSOID_KHACHIYAN_APPROX_IMPL_H
#include <CGAL/license/Bounding_volumes.h>
// Note: whenever a comment refers to "Khachiyan's paper" then the
// paper "Rounding of polytopes in the real number model of
// computation" is meant (Mathematics of Operations Research, Vol. 21,
@ -663,3 +668,5 @@ namespace CGAL {
}
}
#endif // CGAL_APPROX_MIN_ELLIPSOID_KHACHIYAN_APPROX_IMPL_H

7
Bounding_volumes/include/CGAL/Min_circle_2/Min_circle_2_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Sven Schoenherr <sven@inf.ethz.ch>, Bernd Gaertner
#ifndef CGAL_MIN_CIRCLE_2_MIN_CIRCLE_2_IMPL_H
#define CGAL_MIN_CIRCLE_2_MIN_CIRCLE_2_IMPL_H
#include <CGAL/license/Bounding_volumes.h>
#include <iterator>
namespace CGAL {
@ -98,3 +103,5 @@ operator >> ( std::istream& is, CGAL::Min_circle_2<Traits_>& min_circle)
} //namespace CGAL
// ===== EOF ==================================================================
#endif // CGAL_MIN_CIRCLE_2_MIN_CIRCLE_2_IMPL_H

7
Bounding_volumes/include/CGAL/Min_circle_2/Optimisation_circle_2_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Sven Schoenherr <sven@inf.ethz.ch>, Bernd Gaertner
#ifndef CGAL_MIN_SPHERE_D_OPTIMISATION_CIRCLE_2_IMPL_H
#define CGAL_MIN_SPHERE_D_OPTIMISATION_CIRCLE_2_IMPL_H
#include <CGAL/license/Bounding_volumes.h>
// includes
# include <CGAL/assertions.h>
@ -89,3 +94,5 @@ operator >> ( std::istream& is, CGAL::Optimisation_circle_2<K_>& c)
} //namespace CGAL
// ===== EOF ==================================================================
#endif //CGAL_MIN_SPHERE_D_OPTIMISATION_CIRCLE_2_IMPL_H

7
Bounding_volumes/include/CGAL/Min_ellipse_2/Min_ellipse_2_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Sven Schoenherr <sven@inf.ethz.ch>, Bernd Gaertner
#ifndef CGAL_MIN_ELLIPSE_2_MIN_ELLIPSE_2_IMP_H
#define CGAL_MIN_ELLIPSE_2_MIN_ELLIPSE_2_IMP_H
#include <CGAL/license/Bounding_volumes.h>
#include <iterator>
namespace CGAL {
@ -98,3 +103,5 @@ operator >> ( std::istream& is, CGAL::Min_ellipse_2<Traits_>& min_ellipse)
} //namespace CGAL
// ===== EOF ==================================================================
#endif // CGAL_MIN_ELLIPSE_2_MIN_ELLIPSE_2_IMP_H

7
Bounding_volumes/include/CGAL/Min_ellipse_2/Optimisation_ellipse_2_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Sven Schoenherr <sven@inf.ethz.ch>, Bernd Gaertner
#ifndef CGAL_MIN_ELLIPSE_2_OPTIMISATION_ELLIPSE_2_IMPL_H
#define CGAL_MIN_ELLIPSE_2_OPTIMISATION_ELLIPSE_2_IMPL_H
#include <CGAL/license/Bounding_volumes.h>
namespace CGAL {
// Class implementation (continued)
@ -116,3 +121,5 @@ operator >> ( std::istream& is, CGAL::Optimisation_ellipse_2<K_>& e)
} //namespace CGAL
// ===== EOF ==================================================================
#endif // CGAL_MIN_ELLIPSE_2_OPTIMISATION_ELLIPSE_2_IMPL_H

7
Bounding_volumes/include/CGAL/Min_sphere_d/Min_sphere_d_impl.h
View File

@ -11,6 +11,11 @@
// Author(s) : Sven Schoenherr <sven@inf.fu-berlin.de>
// Bernd Gaertner
#ifndef CGAL_MIN_SPHERE_D_MIN_SPHERE_D_IMPL_H
#define CGAL_MIN_SPHERE_D_MIN_SPHERE_D_IMPL_H
#include <CGAL/license/Bounding_volumes.h>
#include <iterator>
namespace CGAL {
@ -105,3 +110,5 @@ operator >> ( std::istream& is, Min_sphere_d<Traits>& min_sphere)
} //namespace CGAL
// ===== EOF ==================================================================
#endif //CGAL_MIN_SPHERE_D_MIN_SPHERE_D_IMPL_H

2
Circular_kernel_2/include/CGAL/Circular_kernel_2/interface_macros.h
View File

@ -9,6 +9,8 @@
//
// Author(s) : Monique Teillaud, Sylvain Pion, Pedro Machado
#include <CGAL/license/Circular_kernel_2.h>
// Partially supported by the IST Programme of the EU as a Shared-cost
// RTD (FET Open) Project under Contract No IST-2000-26473
// (ECG - Effective Computational Geometry for Curves and Surfaces)

2
Circular_kernel_2/include/CGAL/Filtered_bbox_circular_kernel_2/interface_macros.h
View File

@ -9,6 +9,8 @@
//
// Author(s) : Monique Teillaud, Sylvain Pion, Pedro Machado
#include <CGAL/license/Circular_kernel_2.h>
// Partially supported by the IST Programme of the EU as a Shared-cost
// RTD (FET Open) Project under Contract No IST-2000-26473
// (ECG - Effective Computational Geometry for Curves and Surfaces)

2
Circular_kernel_3/include/CGAL/Circular_kernel_3/interface_macros.h
View File

@ -10,6 +10,8 @@
// Author(s) : Monique Teillaud, Sylvain Pion, Pedro Machado,
// Sebastien Loriot, Julien Hazebrouck, Damien Leroy
#include <CGAL/license/Circular_kernel_3.h>
// Partially supported by the IST Programme of the EU as a
// STREP (FET Open) Project under Contract No IST-006413
// (ACS -- Algorithms for Complex Shapes)

7
Partition_2/include/CGAL/Partition_2/Rotation_tree_2_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Susan Hert <hert@mpi-sb.mpg.de>
#ifndef CGAL_PARTITION_2_ROTATION_TREE_2_IMPL_H
#define CGAL_PARTITION_2_ROTATION_TREE_2_IMPL_H
#include <CGAL/license/Partition_2.h>
#include <iostream>
namespace CGAL {
@ -130,3 +135,5 @@ std::ostream& operator<<(std::ostream& os, const Rotation_tree_2<Traits>& tree)
}
}
#endif // CGAL_PARTITION_2_ROTATION_TREE_2_IMPL_H

7
Partition_2/include/CGAL/Partition_2/Vertex_visibility_graph_2_impl.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Susan Hert <hert@mpi-sb.mpg.de>
#ifndef CGAL_PARTITION_2_VERTEX_VISIBILITY_GRAPH_2_IMPL_H
#define CGAL_PARTITION_2_VERTEX_VISIBILITY_GRAPH_2_IMPL_H
#include <CGAL/license/Partition_2.h>
namespace CGAL {
@ -699,3 +704,5 @@ void Vertex_visibility_graph_2<Traits>::handle(Tree_iterator p,
}
}
#endif // CGAL_PARTITION_2_VERTEX_VISIBILITY_GRAPH_2_IMPL_H

2
Periodic_2_triangulation_2/include/CGAL/Periodic_2_triangulation_dummy_12.h
View File

@ -9,6 +9,8 @@
//
// Author(s) : Nico Kruithof <Nico@nghk.nl>
#include <CGAL/license/Periodic_2_triangulation_2.h>
#ifdef CGAL_INCLUDE_FROM_PERIODIC_2_TRIANGULATION_2_H
#include <vector>

2
Periodic_3_triangulation_3/include/CGAL/Periodic_3_triangulation_3/internal/Periodic_3_regular_triangulation_dummy_288.h
View File

@ -10,6 +10,8 @@
//
// Author(s) : Manuel Caroli <Manuel.Caroli@sophia.inria.fr>
#include <CGAL/license/Periodic_3_triangulation_3.h>
#ifdef CGAL_INCLUDE_FROM_PERIODIC_3_REGULAR_TRIANGULATION_3_H
std::vector<Weighted_point> dummy_points()

2
Periodic_3_triangulation_3/include/CGAL/Periodic_3_triangulation_3/internal/Periodic_3_triangulation_dummy_36.h
View File

@ -10,6 +10,8 @@
//
// Author(s) : Manuel Caroli <Manuel.Caroli@sophia.inria.fr>
#include <CGAL/license/Periodic_3_triangulation_3.h>
#ifdef CGAL_INCLUDE_FROM_PERIODIC_3_TRIANGULATION_3_H
template < class GT, class TDS >

2
Periodic_3_triangulation_3/include/CGAL/Periodic_3_triangulation_3/internal/Periodic_3_triangulation_dummy_generator.h
View File

@ -10,6 +10,8 @@
//
// Author(s) : Mael Rouxel-Labbé
#include <CGAL/license/Periodic_3_triangulation_3.h>
#ifdef CGAL_INCLUDE_FROM_PERIODIC_3_TRIANGULATION_3_H
template < class GT, class TDS >

228
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Hole_filling/experimental/experimental_code.h
View File

@ -1,228 +0,0 @@
// Copyright (c) 2015 GeometryFactory (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Ilker O. Yaz
/************************************************************************
* Currently not useful code pieces, in case there will be any need in the future.
* Also they might not work when they plugged-in due to recent changes.
************************************************************************/
// It can produce a patch from both complete and incomplete lambda
// WARNING: Not working good for all cases
// For holes, this code first close them then erase them.
// However the algorithm might produce holes which are invalid to close (closing them breaks edge manifoldness, so erasing doesn't work)
template<class Polyhedron, class OutputIteratorPatch, class OutputIteratorHole>
struct Tracer_polyhedron_incomplete
{
typedef typename Polyhedron::Halfedge_handle Halfedge_handle;
typedef typename Polyhedron::Facet_handle Facet_handle;
Tracer_polyhedron_incomplete(OutputIteratorPatch out,
OutputIteratorHole out_hole,
Polyhedron& polyhedron,
std::vector<Halfedge_handle>& P)
: out(out), out_hole(out_hole), polyhedron(polyhedron), P(P)
{ }
template <class LookupTable>
void
operator()(const LookupTable& lambda, int i, int k)
{
std::vector<Facet_handle> facets_to_delete;
(*this)(lambda, i, k, facets_to_delete, true);
for(typename std::vector<Facet_handle>::iterator it = facets_to_delete.begin();
it != facets_to_delete.end(); ++it)
{
*out_hole++=(*it)->halfedge(); // each deleted facet corresponds to a new hole
polyhedron.erase_facet((*it)->halfedge());
}
}
private:
template <class LookupTable>
Halfedge_handle
operator()(const LookupTable& lambda,
int i, int k,
std::vector<Facet_handle>& facets_to_delete,
bool last)
{
if(i + 1 == k) { return P[i+1]; }
Halfedge_handle h, g;
if(i+2 == k){
if(last)
{ h = polyhedron.fill_hole(P[i+1]); }
else
{ h = polyhedron.add_facet_to_border(P[i+1]->prev(), P[i+2/*k*/]); }
CGAL_assertion(h->facet() != Facet_handle());
int la = lambda.get(i, k);
if(la == -1) {
facets_to_delete.push_back(h->facet());
}
else {
*out++ = h->facet();
}
return h->opposite();
}
else
{
int la = lambda.get(i, k);
if(la == -1) {
if(last)
{ h = polyhedron.fill_hole(P[i+1]); }
else
{ h = polyhedron.add_facet_to_border(P[i+1]->prev(), P[i+2/*k*/]); }
facets_to_delete.push_back(h->facet());
return h->opposite();
}
else {
h = operator()(lambda, i, la, facets_to_delete, false);
g = operator()(lambda, la, k, facets_to_delete, false);
if(last)
{ h = polyhedron.fill_hole(g); }
else
{ h = polyhedron.add_facet_to_border(h->prev(), g); }
CGAL_assertion(h->facet() != Facet_handle());
*out++ = h->facet();
return h->opposite();
}
}
}
public:
OutputIteratorPatch out;
OutputIteratorHole out_hole;
Polyhedron& polyhedron;
std::vector<Halfedge_handle>& P;
};
// Try closing holes by gathering incomplete patches together (an external approach)
template <typename OutputIteratorValueType, typename InputIterator, typename OutputIterator>
OutputIterator
triangulate_hole_polyline_incomplete(InputIterator pbegin, InputIterator pend,
InputIterator qbegin, InputIterator qend,
OutputIterator out)
{
typedef typename std::iterator_traits<InputIterator>::value_type Point_3;
typedef Weight_incomplete<Weight_min_max_dihedral_and_area> Weight;
typedef Weight_calculator<Weight, Is_valid_degenerate_triangle> WC;
typedef std::vector<std::tuple<int, int, int> > Facet_vector; /* deliberately not OutputIteratorValueType*/
typedef std::back_insert_iterator<Facet_vector> OutIt;
typedef Tracer_polyline_incomplete<Facet_vector::value_type, OutIt> Tracer;
typedef std::pair<int, int> Range;
std::vector<Point_3> P(pbegin, pend);
std::vector<Point_3> Q(qbegin, qend);
if(P.front() != P.back()){
P.push_back(P.front());
if( !Q.empty() && P.size() > Q.size()) {
Q.push_back(Q.front());
}
}
std::vector<OutputIteratorValueType> patch_facets;
std::stack<Range> remaining_holes;
remaining_holes.push(Range(0, P.size() -2));
while(!remaining_holes.empty()) {
Range h = remaining_holes.top();
remaining_holes.pop();
std::vector<Point_3> P_r(&P[h.first], (&P[h.second]) + 1);
std::vector<Point_3> Q_r;
if(!Q.empty()) { Q_r.insert(Q_r.begin(), &Q[h.first], (&Q[h.second]) + 1); };
Facet_vector new_facets;
OutIt new_facets_out(new_facets);
std::vector<Range> new_holes;
std::back_insert_iterator<std::vector<Range> > new_holes_out(new_holes);
Tracer tracer(new_facets_out, new_holes_out);
triangulate_hole_polyline(P_r, Q_r, tracer, WC(), true, true);
if(new_facets.empty()) {
new_holes.clear();
//triangulate_hole_polyline(P_r, Q_r, tracer, WC(), false, true);
if(new_facets.empty()) {
// if no patch facets created and also we are using brute force approach, then there is nothing to do,
// leave `out` intact and return
CGAL_warning_msg(false, "Returning no output. Filling hole with incomplete patches is not successful!");
return out;
}
}
// put new borders to remaining_holes
for(typename std::vector<Range>::iterator it = new_holes.begin(); it != new_holes.end(); ++it) {
remaining_holes.push(std::make_pair(it->first + h.first, it->second + h.first));
}
tracer.remaining_holes.clear();
for(Facet_vector::iterator it = new_facets.begin(); it != new_facets.end(); ++it) {
patch_facets.push_back(
OutputIteratorValueType(it->get<0>() + h.first, it->get<1>() + h.first, it->get<2>() + h.first));
}
}
return std::copy(patch_facets.begin(), patch_facets.end(), out);
}
// (for Polyhedron_3) Try closing holes by gathering incomplete patches together (an external approach)
template<class Polyhedron, class OutputIterator>
std::pair<OutputIterator, Weight_min_max_dihedral_and_area>
triangulate_hole_Polyhedron_incomplete(Polyhedron& polyhedron,
typename Polyhedron::Halfedge_handle border_halfedge,
OutputIterator out)
{
typedef typename Polyhedron::Halfedge_handle Halfedge_handle;
typedef typename Polyhedron::Facet_handle Facet_handle;
Weight_min_max_dihedral_and_area weight_total = Weight_min_max_dihedral_and_area::DEFAULT();
std::vector<Facet_handle> patch_facets;
std::stack<Halfedge_handle> remaining_holes;
remaining_holes.push(border_halfedge);
while(!remaining_holes.empty()) {
Halfedge_handle h = remaining_holes.top();
remaining_holes.pop();
std::vector<Halfedge_handle> holes_h;
std::size_t patch_facets_before = patch_facets.size();
Weight_min_max_dihedral_and_area w =
triangulate_hole_Polyhedron(polyhedron, h, back_inserter(patch_facets), back_inserter(holes_h), true);
if(patch_facets_before == patch_facets.size()) {
holes_h.clear();
patch_facets_before = patch_facets.size();
w = triangulate_hole_Polyhedron(polyhedron, h, back_inserter(patch_facets), back_inserter(holes_h), false);
if(patch_facets_before == patch_facets.size()) {
// if no patch facets created and also we are using brute force approach, then there is nothing to do,
// leave `out` intact and return
CGAL_warning_msg(false, "Returning no output. Filling hole with incomplete patches is not successful!");
return std::make_pair(out, Weight_min_max_dihedral_and_area::NOT_VALID());
}
}
// put new borders to remaining_holes and update weight
for(typename std::vector<Halfedge_handle>::iterator it = holes_h.begin(); it != holes_h.end(); ++it) {
//remaining_holes.push(*it);
}
weight_total = weight_total + w;
}
out = std::copy(patch_facets.begin(), patch_facets.end(), out);
return std::make_pair(out, weight_total);
}

8
Polygon_mesh_processing/include/CGAL/polygon_mesh_processing.h
View File

@ -17,6 +17,11 @@
* the free functions of this package.
*/
#ifndef CGAL_POLYGON_MESH_PROCESSING_H
#define CGAL_POLYGON_MESH_PROCESSING_H
#include <CGAL/license/Polygon_mesh_processing/core.h>
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
#include <CGAL/Polygon_mesh_processing/self_intersections.h>
#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
@ -49,3 +54,6 @@
#include <CGAL/Polygon_mesh_processing/smooth_mesh.h>
#include <CGAL/Polygon_mesh_processing/smooth_shape.h>
#include <CGAL/Polygon_mesh_processing/manifoldness.h>
#include <CGAL/Polygon_mesh_processing/autorefinement.h>
#endif //CGAL_POLYGON_MESH_PROCESSING_H

7
QP_solver/include/CGAL/QP_solver/Initialization.h
View File

@ -13,6 +13,11 @@
// Franz Wessendorp
// Kaspar Fischer
#ifndef CGAL_QP_SOLVER_INITIALIZATION_H
#define CGAL_QP_SOLVER_INITIALIZATION_H
#include <CGAL/license/QP_solver.h>
#include<CGAL/QP_functions.h>
#include<CGAL/NT_converter.h>
@ -664,3 +669,5 @@ init_additional_data_members()
} //namespace CGAL
// ===== EOF ==================================================================
#endif //CGAL_QP_SOLVER_INITIALIZATION_H

7
QP_solver/include/CGAL/QP_solver/QP__filtered_base_impl.h
View File

@ -13,6 +13,11 @@
// Franz Wessendorp
// Kaspar Fischer
#ifndef CGAL_QP_FILTERED_BASE_IMPL_H
#define CGAL_QP_FILTERED_BASE_IMPL_H
#include <CGAL/license/QP_solver.h>
namespace CGAL {
// =============================
@ -370,3 +375,5 @@ transition( )
} //namespace CGAL
// ===== EOF ==================================================================
#endif // CGAL_QP_FILTERED_BASE_IMPL_H

7
QP_solver/include/CGAL/QP_solver/QP_basis_inverse_impl.h
View File

@ -13,6 +13,11 @@
// Franz Wessendorp
// Kaspar Fischer
#ifndef CGAL_QP_SOLVER_QP_BASIS_INVERSE_IMPL_H
#define CGAL_QP_SOLVER_QP_BASIS_INVERSE_IMPL_H
#include <CGAL/license/QP_solver.h>
namespace CGAL {
// =============================
@ -700,3 +705,5 @@ print( )
} //namespace CGAL
// ===== EOF ==================================================================
#endif //CGAL_QP_SOLVER_QP_BASIS_INVERSE_IMPL_H

7
QP_solver/include/CGAL/QP_solver/QP_solver_bounds_impl.h
View File

@ -13,6 +13,11 @@
// Franz Wessendorp
// Kaspar Fischer
#ifndef CGAL_QP_SOLVER_QP_SOLVER_BOUNDS_IMPL_H
#define CGAL_QP_SOLVER_QP_SOLVER_BOUNDS_IMPL_H
#include <CGAL/license/QP_solver.h>
namespace CGAL {
template < typename Q, typename ET, typename Tags >
@ -89,3 +94,5 @@ QP_solver<Q, ET, Tags>::upper_bnd(int i) const
} //namespace CGAL
// ===== EOF ==================================================================
#endif //CGAL_QP_SOLVER_QP_SOLVER_BOUNDS_IMPL_H

7
QP_solver/include/CGAL/QP_solver/QP_solver_impl.h
View File

@ -13,6 +13,11 @@
// Franz Wessendorp
// Kaspar Fischer
#ifndef CGAL_QP_SOLVER_IMPL_H
#define CGAL_QP_SOLVER_IMPL_H
#include <CGAL/license/QP_solver.h>
#include <CGAL/QP_solver/Initialization.h>
#include <CGAL/NT_converter.h>
@ -3393,3 +3398,5 @@ get_l() const
} //namespace CGAL
// ===== EOF ==================================================================
#endif //CGAL_QP_SOLVER_IMPL_H

7
QP_solver/include/CGAL/QP_solver/QP_solver_nonstandardform_impl.h
View File

@ -13,6 +13,11 @@
// Franz Wessendorp
// Kaspar Fischer
#ifndef CGAL_QP_SOLVER_NONSTANDARDFORM_IMPL_H
#define CGAL_QP_SOLVER_NONSTANDARDFORM_IMPL_H
#include <CGAL/license/QP_solver.h>
namespace CGAL {
// Looks in x_O_v_i which bound is present for variable i and returns
@ -219,3 +224,5 @@ init_w()
} //namespace CGAL
// ===== EOF ==================================================================
#endif CGAL_QP_SOLVER_NONSTANDARDFORM_IMPL_H

6
Segment_Delaunay_graph_2/include/CGAL/Segment_Delaunay_graph_2/Segment_Delaunay_graph_2_impl.h
View File

@ -10,6 +10,10 @@
//
// Author(s) : Menelaos Karavelas <mkaravel@iacm.forth.gr>
#ifndef CGAL_SEGMENT_DELAUNAY_GRAPH_2_SDG_2_IMPL_H
#define CGAL_SEGMENT_DELAUNAY_GRAPH_2_SDG_2_IMPL_H
#include <CGAL/license/Segment_Delaunay_graph_2.h>
// class implementation continued
//=================================
@ -3325,3 +3329,5 @@ file_input(std::istream& is, bool read_handle_vector,
} //namespace CGAL
// EOF
#endif // CGAL_SEGMENT_DELAUNAY_GRAPH_2_SDG_2_IMPL_H

5
Segment_Delaunay_graph_2/include/CGAL/Segment_Delaunay_graph_2/Segment_Delaunay_graph_hierarchy_2_impl.h
View File

@ -10,7 +10,10 @@
//
// Author(s) : Menelaos Karavelas <mkaravel@iacm.forth.gr>
#ifndef CGAL_SEGMENT_DELAUNAY_GRAPH_2_SDG_HIERARCHY_IMPL_H
#define CGAL_SEGMENT_DELAUNAY_GRAPH_2_SDG_HIERARCHY_IMPL_H
#include <CGAL/license/Segment_Delaunay_graph_2.h>
// class implementation continued
@ -1145,3 +1148,5 @@ file_input(std::istream& is)
// EOF
#endif //CGAL_SEGMENT_DELAUNAY_GRAPH_2_SDG_HIERARCHY_IMPL_H

7
Segment_Delaunay_graph_Linf_2/include/CGAL/Segment_Delaunay_graph_Linf_2/Segment_Delaunay_graph_Linf_2_impl.h
View File

@ -11,6 +11,11 @@
// Author(s) : Panagiotis Cheilaris, Sandeep Kumar Dey, Evanthia Papadopoulou
//philaris@gmail.com, sandeep.kr.dey@gmail.com, evanthia.papadopoulou@usi.ch
#ifndef CGAL_SEGMENT_DELAUNAY_GRAPH_LINF_2_SDG_LINF_2_IMPL_H
#define CGAL_SEGMENT_DELAUNAY_GRAPH_LINF_2_SDG_LINF_2_IMPL_H
#include <CGAL/license/Segment_Delaunay_graph_Linf_2.h>
namespace CGAL {
// print face in standard output
@ -759,3 +764,5 @@ insert_point_on_segment(const Storage_site_2& ss, const Site_2& ,
} //namespace CGAL
// EOF
#endif // CGAL_SEGMENT_DELAUNAY_GRAPH_LINF_2_SDG_LINF_2_IMPL_H

8
Surface_mesh_parameterization/include/CGAL/surface_mesh_parameterization.h
View File

@ -10,6 +10,11 @@
//
// Author(s) : Mael Rouxel-Labbé
#ifndef CGAL_SURFACE_MESH_PARAMETERIZATION_H
#define CGAL_SURFACE_MESH_PARAMETERIZATION_H
#include <CGAL/license/Surface_mesh_parameterization.h>
/**
* \ingroup PkgSurfaceMeshParameterizationRef
* \file CGAL/surface_mesh_parameterization.h
@ -17,7 +22,6 @@
* the free functions of this package.
*/
#include <CGAL/Surface_mesh_parameterization/ARAP_parameterizer_3.h>
#include <CGAL/Surface_mesh_parameterization/Barycentric_mapping_parameterizer_3.h>
#include <CGAL/Surface_mesh_parameterization/Discrete_authalic_parameterizer_3.h>
@ -34,3 +38,5 @@
#include <CGAL/Surface_mesh_parameterization/Circular_border_parameterizer_3.h>
#include <CGAL/Surface_mesh_parameterization/Square_border_parameterizer_3.h>
#include <CGAL/Surface_mesh_parameterization/Two_vertices_parameterizer_3.h>
#endif // CGAL_SURFACE_MESH_PARAMETERIZATION_H

7
Surface_mesher/include/CGAL/make_piecewise_smooth_surface_mesh.h
View File

@ -9,4 +9,11 @@
//
// Author(s) : Laurent Rineau
#ifndef CGAL_MAKE_PIECEWISE_SMOOTH_SURFACE_MESH_H
#define CGAL_MAKE_PIECEWISE_SMOOTH_SURFACE_MESH_H
#include <CGAL/license/Surface_mesher.h>
#include <CGAL/make_surface_mesh.h>
#endif //CGAL_MAKE_PIECEWISE_SMOOTH_SURFACE_MESH_H