mirror of https://github.com/CGAL/cgal
issue #8515 Spelling mistakes found checking `en-GB` to `en-US`
Spelling corrections, `en-GB` -> `en-US`
This commit is contained in:
albert-github
parent
4305f01384
commit
dd02af92a2
|
|
@ -56,7 +56,7 @@ public:
|
|||
/**
|
||||
* @brief General traversal query
|
||||
* @param query the query
|
||||
* @param traits the traversal traits that define the traversal behaviour
|
||||
* @param traits the traversal traits that define the traversal behavior
|
||||
* @param nb_primitives the number of primitive
|
||||
*
|
||||
* General traversal query. The traits class allows using it for the various
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ class Bitstream_descartes;
|
|||
|
||||
|
||||
/*
|
||||
* \brief Thrown whenever a non-specialised virtual member function is called
|
||||
* \brief Thrown whenever a non-specialized virtual member function is called
|
||||
*/
|
||||
class Virtual_method_exception {};
|
||||
|
||||
|
|
@ -128,7 +128,7 @@ public:
|
|||
|
||||
/*!
|
||||
* Constructor computing an interval containing all real roots of \c f,
|
||||
* and initialising the Bitstream Descartes tree
|
||||
* and initializing the Bitstream Descartes tree
|
||||
*/
|
||||
Generic_descartes_rep(Bitstream_descartes_type type,
|
||||
Polynomial f,
|
||||
|
|
@ -170,7 +170,7 @@ public:
|
|||
|
||||
/*!
|
||||
* Constructor that copies the Bitstream tree given from outside
|
||||
* and initialising the Bitstream Descartes tree
|
||||
* and initializing the Bitstream Descartes tree
|
||||
* The tree must "fit" to the polynomial
|
||||
*/
|
||||
Generic_descartes_rep(Bitstream_descartes_type type,
|
||||
|
|
@ -367,7 +367,7 @@ public:
|
|||
/*!
|
||||
* \brief When does the isolation algorithm terminate?
|
||||
*
|
||||
* This method must be specialised by derived classes
|
||||
* This method must be specialized by derived classes
|
||||
*/
|
||||
virtual bool termination_condition() {
|
||||
throw Virtual_method_exception();
|
||||
|
|
@ -378,7 +378,7 @@ public:
|
|||
* \brief gives an opportunity to process the nodes after
|
||||
* the subdivision steps are finished
|
||||
*
|
||||
* This method must be specialised by derived classes, but can
|
||||
* This method must be specialized by derived classes, but can
|
||||
* remain empty in many cases.
|
||||
*/
|
||||
virtual void process_nodes() {
|
||||
|
|
@ -389,7 +389,7 @@ public:
|
|||
/*! \brief returns whether the \c i th root is definitely a simple root
|
||||
* of the isolated polynomial
|
||||
*
|
||||
* Must be specialised by derived class
|
||||
* Must be specialized by derived class
|
||||
*/
|
||||
virtual bool is_certainly_simple_root(int) const {
|
||||
throw Virtual_method_exception();
|
||||
|
|
@ -399,7 +399,7 @@ public:
|
|||
/*! \brief returns whether the \c i th root is definitely a multiple root
|
||||
* of the isolated polynomial
|
||||
*
|
||||
* Must be specialised by derived class
|
||||
* Must be specialized by derived class
|
||||
*/
|
||||
virtual bool is_certainly_multiple_root(int) const {
|
||||
throw Virtual_method_exception();
|
||||
|
|
@ -1082,7 +1082,7 @@ protected:
|
|||
* variant of the Bitstream Descartes method: The Square_free_descartes_tag
|
||||
* starts the usual Bitstream method for square free integer polynomials.
|
||||
* With the M_k_descartes tag, it is able to handle one multiple root in
|
||||
* favourable situations, the Backshear_descartes_tag allows to isolate
|
||||
* favorable situations, the Backshear_descartes_tag allows to isolate
|
||||
* even more complicated polynomials, if the multiple roots with even
|
||||
* multiplicity can be refined from outside. See the corresponding
|
||||
* constructors for more information.
|
||||
|
|
|
|||
|
|
@ -865,7 +865,7 @@ public:
|
|||
by trying randomly and checking. This randomization means
|
||||
the same polynomial and same initial interval may give rise
|
||||
to different intervals each time this class is used.
|
||||
As indicated in the paper, we favour subdivision ratios
|
||||
As indicated in the paper, we favor subdivision ratios
|
||||
with a small denominator. Hence we first try denominator
|
||||
2 (subdivision at midpoint), then denominator 16, and
|
||||
only then the "proper" denominator prescribed by theory.
|
||||
|
|
|
|||
|
|
@ -469,7 +469,7 @@ public:
|
|||
* (\c SHEAR_ONLY_AT_IRRATIONAL_STRATEGY)
|
||||
* is to \c shear the curve
|
||||
* if a degenerate situation is detected during the analysis,
|
||||
* except at rational x-coordinates where the curve can be analysed
|
||||
* except at rational x-coordinates where the curve can be analyzed
|
||||
* more directly. The analysis
|
||||
* is then performed in the sheared system, and finally translated back
|
||||
* into the original system.
|
||||
|
|
|
|||
|
|
@ -140,7 +140,7 @@ public:
|
|||
virtual ~LRU_hashed_map()
|
||||
{ }
|
||||
|
||||
/*! \brief implements cache-like behaviour of the map
|
||||
/*! \brief implements cache-like behavior of the map
|
||||
*
|
||||
* If the object is not in the map, it is constructed using \c Creator
|
||||
* and added to the map
|
||||
|
|
@ -312,7 +312,7 @@ public:
|
|||
~LRU_hashed_map_with_kernel()
|
||||
{ }
|
||||
|
||||
/*! \brief implements cache-like behaviour of the map
|
||||
/*! \brief implements cache-like behavior of the map
|
||||
*
|
||||
* If the object is not in the map, it is constructed using \c Creator
|
||||
* and added to the map
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ namespace CGAL {
|
|||
/*!
|
||||
* \brief Exception class for not sufficiently generic positions.
|
||||
*
|
||||
* Must be thrown whenever a curve cannot be analysed because its position
|
||||
* Must be thrown whenever a curve cannot be analyzed because its position
|
||||
* is not "good enough".
|
||||
*/
|
||||
class Non_generic_position_exception {
|
||||
|
|
@ -40,7 +40,7 @@ namespace CGAL {
|
|||
/*!
|
||||
* \brief Exception class for not sufficiently generic positions.
|
||||
*
|
||||
* Must be thrown whenever a curve cannot be analysed because its position
|
||||
* Must be thrown whenever a curve cannot be analyzed because its position
|
||||
* is not "good enough".
|
||||
*/
|
||||
template<typename Polynomial>
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@
|
|||
|
||||
/**
|
||||
* If set, the curve and curve pair analysis are using specialized code
|
||||
* to analyse conic curves, i.e. curves of degree 2
|
||||
* to analyze conic curves, i.e. curves of degree 2
|
||||
*/
|
||||
#ifndef CGAL_ACK_USE_SPECIAL_TREATMENT_FOR_CONIX
|
||||
#define CGAL_ACK_USE_SPECIAL_TREATMENT_FOR_CONIX 0
|
||||
|
|
|
|||
|
|
@ -330,7 +330,7 @@ template<typename Arithmetic_kernel> void test_routine() {
|
|||
#endif
|
||||
}
|
||||
|
||||
{ // More tests...just analyse some curves and compute their segments
|
||||
{ // More tests...just analyze some curves and compute their segments
|
||||
Poly_int2 f = from_string<Poly_int2>("P[8(0,P[8(0,24)(1,-8)(2,-162)(3,204)(4,106)(5,-340)(6,240)(7,-72)(8,8)])(1,P[6(0,-60)(1,8)(2,304)(3,-400)(4,148)(5,8)(6,-8)])(2,P[6(0,18)(1,80)(2,-165)(3,-132)(4,367)(5,-212)(6,38)])(3,P[4(0,-30)(1,-136)(2,264)(3,-72)(4,-26)])(4,P[4(0,-15)(1,36)(2,89)(3,-144)(4,49)])(5,P[2(0,30)(1,-24)(2,-6)])(6,P[2(0,-6)(1,-28)(2,22)])(8,P[0(0,3)])]");
|
||||
Curve_analysis_2 curve= construct_curve_2(f);
|
||||
#if CGAL_ACK_DEBUG_FLAG
|
||||
|
|
|
|||
|
|
@ -1638,7 +1638,7 @@ compute_edge_status( const Cell_handle& c,
|
|||
last=ccirc;
|
||||
while (is_infinite(ccirc) ) ++ccirc; //skip infinite incident cells
|
||||
alpha = (*ccirc).get_alpha();
|
||||
as.set_alpha_mid(alpha); // initialise as.alpha_mid to alpha value of an incident cell
|
||||
as.set_alpha_mid(alpha); // initialize as.alpha_mid to alpha value of an incident cell
|
||||
as.set_alpha_max(alpha); // same for as.alpha_max
|
||||
while (++ccirc != last)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ test_filtration(AS &A, bool verbose)
|
|||
typename AS::NT alpha;
|
||||
if(verbose) {
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "Analyse filtration " << std::endl;
|
||||
std::cerr << "Analyze filtration " << std::endl;
|
||||
}
|
||||
for (; filtre_it != filtration.end(); filtre_it++) {
|
||||
if(assign(vertex, *filtre_it)) {
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ namespace {
|
|||
Flag(bool init) : v{ init } {}
|
||||
};
|
||||
|
||||
// EXTENDED AOS for analysing the arrangement
|
||||
// EXTENDED AOS for analyzing the arrangement
|
||||
using Ext_dcel = CGAL::Arr_extended_dcel<Geom_traits, Flag, Flag, Flag>;
|
||||
using Ext_topol_traits =
|
||||
CGAL::Arr_spherical_topology_traits_2<Geom_traits, Ext_dcel>;
|
||||
|
|
|
|||
|
|
@ -339,7 +339,7 @@ public:
|
|||
if (! valid)
|
||||
return;
|
||||
|
||||
// Analyze the behaviour of the rational function at x = -oo (the source).
|
||||
// Analyze the behavior of the rational function at x = -oo (the source).
|
||||
Algebraic y0;
|
||||
const Arr_parameter_space inf_s =
|
||||
_analyze_at_minus_infinity (_numer, _denom, y0);
|
||||
|
|
@ -351,7 +351,7 @@ public:
|
|||
else // if (inf_s == ARR_INTERIOR)
|
||||
_ps = Point_2 (0, y0);
|
||||
|
||||
// Analyze the behaviour of the rational function at x = +oo (the target).
|
||||
// Analyze the behavior of the rational function at x = +oo (the target).
|
||||
const Arr_parameter_space inf_t =
|
||||
_analyze_at_plus_infinity (_numer, _denom, y0);
|
||||
|
||||
|
|
@ -735,7 +735,7 @@ public:
|
|||
*/
|
||||
Self split_at_pole (const Algebraic& x0)
|
||||
{
|
||||
// Analyze the behaviour of the function near the given pole.
|
||||
// Analyze the behavior of the function near the given pole.
|
||||
const std::pair<CGAL::Sign, CGAL::Sign> signs = _analyze_near_pole (x0);
|
||||
const CGAL::Sign sign_left = signs.first;
|
||||
const CGAL::Sign sign_right = signs.second;
|
||||
|
|
|
|||
|
|
@ -450,7 +450,7 @@ public:
|
|||
_info = (_info | IS_DIRECTED_RIGHT);
|
||||
|
||||
|
||||
// Analyze the behaviour of the rational function at x = -oo (the source).
|
||||
// Analyze the behavior of the rational function at x = -oo (the source).
|
||||
Algebraic_real_1 y0;
|
||||
const Arr_parameter_space inf_s = _analyze_at_minus_infinity(P, Q, y0);
|
||||
|
||||
|
|
@ -460,7 +460,7 @@ public:
|
|||
_info = (_info | SRC_AT_Y_PLUS_INFTY);
|
||||
else // if (inf_s == ARR_INTERIOR)
|
||||
_ps = Algebraic_point_2(); //the point is a dummy
|
||||
//Analyze the behaviour of the rational function at x = +oo (the target).
|
||||
//Analyze the behavior of the rational function at x = +oo (the target).
|
||||
const Arr_parameter_space inf_t = _analyze_at_plus_infinity(P, Q, y0);
|
||||
|
||||
if (inf_t == ARR_BOTTOM_BOUNDARY)
|
||||
|
|
@ -949,7 +949,7 @@ public:
|
|||
|
||||
Self split_at_pole(const Algebraic_real_1& x0)
|
||||
{
|
||||
// Analyze the behaviour of the function near the given pole.
|
||||
// Analyze the behavior of the function near the given pole.
|
||||
const std::pair<CGAL::Sign, CGAL::Sign> signs = _analyze_near_pole(x0);
|
||||
const CGAL::Sign sign_left = signs.first;
|
||||
const CGAL::Sign sign_right = signs.second;
|
||||
|
|
|
|||
|
|
@ -1578,7 +1578,7 @@ public:
|
|||
return res;
|
||||
}
|
||||
|
||||
// otherwise: both ends have asymptotic behaviour
|
||||
// otherwise: both ends have asymptotic behavior
|
||||
if (ps_y1 == ps_y2) { // need special y-comparison
|
||||
if (ce1 == ce2) { // both ends approach asymptote from one side
|
||||
Comparison_result res = m_self->compare_x_near_boundary_2_object()(xcv1, xcv2, ce2);
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
* \brief
|
||||
* defines class Curve_renderer_traits.
|
||||
*
|
||||
* provides specialisations of Curve_renderer_traits for different number
|
||||
* provides specializations of Curve_renderer_traits for different number
|
||||
* types compatible with the curve renderer
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -733,7 +733,7 @@ struct Graph_with_descriptor_with_graph_property_map {
|
|||
}
|
||||
}; // class Graph_with_descriptor_with_graph_property_map
|
||||
|
||||
//specialisation for lvaluepropertymaps
|
||||
//specialization for lvaluepropertymaps
|
||||
template <typename Graph, typename PM>
|
||||
struct Graph_with_descriptor_with_graph_property_map<Graph, PM, boost::lvalue_property_map_tag> {
|
||||
|
||||
|
|
|
|||
|
|
@ -542,13 +542,13 @@ boundary of each input (linear) polygon as a cyclic sequence of single
|
|||
(\f$x\f$-monotone) polylines. By default, `UsePolylines` is set to
|
||||
`CGAL::Tag_true`, which implies that the boundary of the each input
|
||||
(linear) polygon is treated as a cyclic sequence of (\f$x\f$-monotone)
|
||||
polylines. In most cases this behaviour is superior (that is, less
|
||||
polylines. In most cases this behavior is superior (that is, less
|
||||
time-consuming) because the number of events handled as part of the
|
||||
execution of the plane-sweep algorithm is reduced. In cases where the
|
||||
boundaries of the input polygons frequently intersect, treating them
|
||||
as polylines may become less efficient. In these cases substitute the
|
||||
`UsePolylines` template parameter with `CGAL::Tag_false` to restore
|
||||
the original behaviour (where the boundary of each input linear
|
||||
the original behavior (where the boundary of each input linear
|
||||
polygon is treated as a cyclic sequence of single \f$x\f$-monotone
|
||||
segments).
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ namespace CGAL {
|
|||
\ingroup PkgBoundingVolumesRef
|
||||
|
||||
The class `Min_sphere_annulus_d_traits_2` is a traits class for the \f$ d\f$-dimensional
|
||||
optimisation algorithms using the two-dimensional \cgal kernel.
|
||||
optimization algorithms using the two-dimensional \cgal kernel.
|
||||
|
||||
\tparam K must bea model for `Kernel`.
|
||||
\tparam ET NT are models for `RingNumberType`. Their default type is `K::RT`.
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ namespace CGAL {
|
|||
\ingroup PkgBoundingVolumesRef
|
||||
|
||||
The class `Min_sphere_annulus_d_traits_3` is a traits class for the \f$ d\f$-dimensional
|
||||
optimisation algorithms using the three-dimensional \cgal kernel.
|
||||
optimization algorithms using the three-dimensional \cgal kernel.
|
||||
|
||||
\tparam K must be a model for `Kernel`.
|
||||
\tparam ET NT are models for `RingNumberType`. Their default type is `K::RT`.
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ namespace CGAL {
|
|||
\ingroup PkgBoundingVolumesRef
|
||||
|
||||
The class `Min_sphere_annulus_d_traits_d` is a traits class for the \f$ d\f$-dimensional
|
||||
optimisation algorithms using the \f$ d\f$-dimensional \cgal kernel.
|
||||
optimization algorithms using the \f$ d\f$-dimensional \cgal kernel.
|
||||
|
||||
\tparam K must be a model for `Kernel`.
|
||||
\tparam ET NT are models for `RingNumberType`. Their default type is `K::RT`.
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ namespace CGAL {
|
|||
std::vector<const Point *> P; // input points
|
||||
int n; // number of input points, i.e., P.size()
|
||||
|
||||
// This class comes in two flavours:
|
||||
// This class comes in two flavors:
|
||||
//
|
||||
// (i) When Embed is false, the input points are taken to be
|
||||
// ordinary points in R^{d_P}, where d_P is the dimension of the
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ namespace CGAL_MINIBALL_NAMESPACE {
|
|||
// they are convertible to double.
|
||||
// This is indeed the least invasive fix dropint the function that were
|
||||
// defined here and cause linkage bug.
|
||||
// You can still have a behaviour of instantiating only if a type
|
||||
// You can still have a behavior of instantiating only if a type
|
||||
// is convertibale to double (by using type_traits together with _if)
|
||||
// but until "the whole design should be overhauled at some point"
|
||||
// this is fine.
|
||||
|
|
|
|||
|
|
@ -376,7 +376,7 @@ min_rectangle_2(
|
|||
|
||||
// quadruple of points defining the current rectangle
|
||||
ForwardIterator curr[4];
|
||||
// initialised to the points defining the bounding box
|
||||
// initialized to the points defining the bounding box
|
||||
convex_bounding_box_2(f, l, curr, t);
|
||||
|
||||
// curr[i] can be advanced (cyclically) until it reaches limit[i]
|
||||
|
|
@ -482,7 +482,7 @@ min_parallelogram_2(ForwardIterator f,
|
|||
|
||||
// quadruple of points defining the bounding box
|
||||
ForwardIterator curr[4];
|
||||
// initialised to the points defining the bounding box
|
||||
// initialized to the points defining the bounding box
|
||||
convex_bounding_box_2(first, l, curr, t);
|
||||
|
||||
|
||||
|
|
@ -659,7 +659,7 @@ min_strip_2(ForwardIterator f,
|
|||
|
||||
// quadruple of points defining the bounding box
|
||||
ForwardIterator curr[4];
|
||||
// initialised to the points defining the bounding box
|
||||
// initialized to the points defining the bounding box
|
||||
convex_bounding_box_2(first, l, curr, t);
|
||||
|
||||
ForwardIterator low = curr[0];
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ rectangular_3_center_2_type1(
|
|||
rad = sdist(v(r, 2), v(r, 0));
|
||||
// init to prevent default constructor requirement
|
||||
Point bestpoint = *f;
|
||||
// (initialisation avoids warning)
|
||||
// (initialization avoids warning)
|
||||
unsigned int bestrun = 0;
|
||||
|
||||
// two cases: top-left & bottom-right or top-right & bottom-left
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
// release : $CGAL_Revision: CGAL-wip $
|
||||
// release_date : $CGAL_Date$
|
||||
//
|
||||
// chapter : $CGAL_Chapter: Optimisation $
|
||||
// chapter : $CGAL_Chapter: Geometric Optimization $
|
||||
// package : $CGAL_Package: MinSphere $
|
||||
// file : min_sphere_test.C
|
||||
// source : web/Optimisation/Min_sphere_d.aw
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@
|
|||
// release : $CGAL_Revision: CGAL-wip $
|
||||
// release_date : $CGAL_Date$
|
||||
//
|
||||
// chapter : $CGAL_Chapter: Optimisation $
|
||||
// chapter : $CGAL_Chapter: Geometric Optimization $
|
||||
// package : $CGAL_Package: MinSphere $
|
||||
// file : min_sphere_traits_2_test.C
|
||||
// source : web/Optimisation/Min_sphere_d.aw
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
// release : $CGAL_Revision: CGAL-wip $
|
||||
// release_date : $CGAL_Date$
|
||||
//
|
||||
// chapter : $CGAL_Chapter: Optimisation $
|
||||
// chapter : $CGAL_Chapter: Geometric Optimization $
|
||||
// package : $CGAL_Package: MinSphere $
|
||||
// file : min_sphere_traits_3_test.C
|
||||
// source : web/Optimisation/Min_sphere_d.aw
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//
|
||||
// file : test/Min_annulus_d/test_Min_annulus_d.h
|
||||
// package : $CGAL_Package: Min_annulus_d $
|
||||
// chapter : Geometric Optimisation
|
||||
// chapter : Geometric Optimization
|
||||
//
|
||||
// source : web/Min_annulus_d.aw
|
||||
// revision : $Id$
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//
|
||||
// file : test/Min_annulus_d/test_Min_annulus_d_2.cpp
|
||||
// package : $CGAL_Package: Min_annulus_d $
|
||||
// chapter : Geometric Optimisation
|
||||
// chapter : Geometric Optimization
|
||||
//
|
||||
// revision : $Id$
|
||||
// revision_date : $Date$
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//
|
||||
// file : test/Min_annulus_d/test_Min_annulus_d_3.cpp
|
||||
// package : $CGAL_Package: Min_annulus_d $
|
||||
// chapter : Geometric Optimisation
|
||||
// chapter : Geometric Optimization
|
||||
//
|
||||
// revision : $Id$
|
||||
// revision_date : $Date$
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//
|
||||
// file : test/Min_annulus_d/test_Min_annulus_d_d.cpp
|
||||
// package : $CGAL_Package: Min_annulus_d $
|
||||
// chapter : Geometric Optimisation
|
||||
// chapter : Geometric Optimization
|
||||
//
|
||||
// revision : $Id$
|
||||
// revision_date : $Date$
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//
|
||||
// file : test/Min_circle_2/test_Min_circle_2.C
|
||||
// package : $CGAL_Package: Min_circle_2 $
|
||||
// chapter : Geometric Optimisation
|
||||
// chapter : Geometric Optimization
|
||||
//
|
||||
// source : web/Min_circle_2.aw
|
||||
// revision : $Id$
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
//
|
||||
// file : test/Min_ellipse_2/test_Min_ellipse_2.C
|
||||
// package : $CGAL_Package: Min_ellipse_2 $
|
||||
// chapter : Geometric Optimisation
|
||||
// chapter : Geometric Optimization
|
||||
//
|
||||
// source : web/Min_ellipse_2.aw
|
||||
// revision : $Id$
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
#include <CGAL/ImageIO.h>
|
||||
|
||||
/* read analyse format header
|
||||
/* read analyze format header
|
||||
|
||||
return:
|
||||
-1: error
|
||||
|
|
|
|||
|
|
@ -108,8 +108,8 @@ typedef std::uint32_t CGAL_UINT32;
|
|||
*/
|
||||
|
||||
/*
|
||||
* Bitmapfileheader defines a single bitmap image. Its analogue in the
|
||||
* Windows SDK is the Bitmapfileheader. Its analogues in the OS/2 Toolkit are
|
||||
* Bitmapfileheader defines a single bitmap image. Its analog in the
|
||||
* Windows SDK is the Bitmapfileheader. Its analogs in the OS/2 Toolkit are
|
||||
* the Bitmapfileheader and Bitmapfileheader2 structures.
|
||||
*
|
||||
* A BITMAPHEADER structure is always concatenated to the end of a
|
||||
|
|
@ -128,7 +128,7 @@ typedef struct Bitmapfileheader
|
|||
/*
|
||||
* BITMAPARRAYHEADER is used to establish a linked list of Bitmapfileheader
|
||||
* structures for a bitmap file with multiple images in it. There is no
|
||||
* equivalent structure in the Windows SDK. Its analogues in the OS/2 toolkit
|
||||
* equivalent structure in the Windows SDK. Its analogs in the OS/2 toolkit
|
||||
* are the BITMAPARRAYFILEHEADER and BITMAPARRAYFILEHEADER2 structures.
|
||||
*
|
||||
* A Bitmapfileheader structure is always concatenated to the end of a
|
||||
|
|
@ -145,9 +145,9 @@ typedef struct BITMAPARRAYHEADER
|
|||
|
||||
|
||||
/*
|
||||
* BITMAPHEADER defines the properties of a bitmap. Its analogues in the
|
||||
* BITMAPHEADER defines the properties of a bitmap. Its analogs in the
|
||||
* Windows SDK are the BITMAPCOREINFOHEADER and BITMAPINFOHEADER structures.
|
||||
* Its analogues in the OS/2 Toolkit are the BITMAPINFOHEADER and
|
||||
* Its analogs in the OS/2 Toolkit are the BITMAPINFOHEADER and
|
||||
* BITMAPINFOHEADER2 structures.
|
||||
*
|
||||
* A color table is concatenated to this structure. The number of elements in
|
||||
|
|
@ -188,8 +188,8 @@ typedef struct BITMAPHEADER
|
|||
|
||||
|
||||
/*
|
||||
* RGB defines a single color palette entry. Its analogues in the Windows SDK
|
||||
* are the RGBTRIPLE and RGBQUAD structures. Its analogues in the OS/2
|
||||
* RGB defines a single color palette entry. Its analogs in the Windows SDK
|
||||
* are the RGBTRIPLE and RGBQUAD structures. Its analogs in the OS/2
|
||||
* Toolkit are the RGB and RGB2 structure.
|
||||
*/
|
||||
typedef struct RGB
|
||||
|
|
|
|||
|
|
@ -283,7 +283,7 @@ RFcoefficientType * InitRecursiveCoefficients( double x,
|
|||
b0 /= x;
|
||||
b1 /= x;
|
||||
|
||||
/*--- normalisation ---*/
|
||||
/*--- normalization ---*/
|
||||
switch ( derivative ) {
|
||||
default :
|
||||
CGAL_FALLTHROUGH;
|
||||
|
|
|
|||
|
|
@ -662,7 +662,7 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
/** Create a new dart and add it to the map.
|
||||
* The marks of the darts are initialised with mmask_marks, i.e. the dart
|
||||
* The marks of the darts are initialized with mmask_marks, i.e. the dart
|
||||
* is unmarked for all the marks.
|
||||
* @return a Dart_descriptor on the new dart.
|
||||
*/
|
||||
|
|
@ -4111,7 +4111,7 @@ namespace CGAL {
|
|||
}
|
||||
if (ah != null_descriptor)
|
||||
{
|
||||
// We initialise the 0-atttrib to ah
|
||||
// We initialize the 0-atttrib to ah
|
||||
internal::Set_i_attribute_of_dart_functor<Self, 0>::
|
||||
run(*this, d1, ah);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -228,7 +228,7 @@ struct Call_functor_if_both_attributes_have_point
|
|||
const Pointconverter&)
|
||||
{ return Map2::null_descriptor; }
|
||||
};
|
||||
// Specialisation with i==0 and both attributes have points.
|
||||
// Specialization with i==0 and both attributes have points.
|
||||
template< typename Map1, typename Map2, typename Pointconverter >
|
||||
struct Call_functor_if_both_attributes_have_point<Map1, Map2, 0,
|
||||
Pointconverter, true, true>
|
||||
|
|
@ -285,7 +285,7 @@ struct Copy_attribute_functor_if_nonvoid
|
|||
cmap2.template set_attribute<i>(dh2, res);
|
||||
}
|
||||
};
|
||||
// Specialisation when attr1 is void, and attr2 is non void i==0. Nothing to
|
||||
// Specialization when attr1 is void, and attr2 is non void i==0. Nothing to
|
||||
// copy, but if 0-attributes has point and i==0, we need to create
|
||||
// vertex attributes.
|
||||
template<typename Map1, typename Map2, typename Converters,
|
||||
|
|
@ -310,7 +310,7 @@ struct Copy_attribute_functor_if_nonvoid<Map1, Map2, Converters,
|
|||
set_attribute<0>(dh2, cmap2.template create_attribute<0>());
|
||||
}
|
||||
};
|
||||
// Specialisation when attr1 is void, and attr2 is non void i!=0.
|
||||
// Specialization when attr1 is void, and attr2 is non void i!=0.
|
||||
// Nothing to do.
|
||||
template<typename Map1, typename Map2, typename Converters, unsigned int i,
|
||||
typename Pointconverter, typename Attr2>
|
||||
|
|
@ -360,7 +360,7 @@ struct Copy_dart_info_functor_if_nonvoid
|
|||
const DartInfoConverter& converter)
|
||||
{ converter(map1, map2, dh1, dh2); }
|
||||
};
|
||||
// Specialisation when Info1 is void.
|
||||
// Specialization when Info1 is void.
|
||||
template<typename Map1, typename Map2, typename DartInfoConverter,
|
||||
typename Info2>
|
||||
struct Copy_dart_info_functor_if_nonvoid<Map1, Map2, DartInfoConverter,
|
||||
|
|
@ -373,7 +373,7 @@ struct Copy_dart_info_functor_if_nonvoid<Map1, Map2, DartInfoConverter,
|
|||
const DartInfoConverter&)
|
||||
{}
|
||||
};
|
||||
// Specialisation when Info2 is void.
|
||||
// Specialization when Info2 is void.
|
||||
template<typename Map1, typename Map2, typename DartInfoConverter,
|
||||
typename Info1>
|
||||
struct Copy_dart_info_functor_if_nonvoid<Map1, Map2, DartInfoConverter,
|
||||
|
|
@ -386,7 +386,7 @@ struct Copy_dart_info_functor_if_nonvoid<Map1, Map2, DartInfoConverter,
|
|||
const DartInfoConverter&)
|
||||
{}
|
||||
};
|
||||
// Specialisation when both Info1 and Info2 are void.
|
||||
// Specialization when both Info1 and Info2 are void.
|
||||
template<typename Map1, typename Map2, typename DartInfoConverter>
|
||||
struct Copy_dart_info_functor_if_nonvoid<Map1, Map2, DartInfoConverter,
|
||||
CGAL::Void, CGAL::Void>
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ namespace CGAL
|
|||
{
|
||||
static bool run(const CMap& amap, typename CMap::Dart_const_descriptor adart)
|
||||
{
|
||||
// TODO? Optimisation for dim-2, and to not test all the darts of the cell?
|
||||
// TODO? Optimization for dim-2, and to not test all the darts of the cell?
|
||||
bool res = true;
|
||||
for ( CGAL::CMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart);
|
||||
res && it.cont(); ++it )
|
||||
|
|
@ -462,7 +462,7 @@ namespace CGAL
|
|||
{
|
||||
static bool run(const CMap& amap, typename CMap::Dart_const_descriptor adart)
|
||||
{
|
||||
// TODO ? Optimisation possible to not test all the darts of the cell ?
|
||||
// TODO ? Optimization possible to not test all the darts of the cell ?
|
||||
bool res = true;
|
||||
for ( CGAL::CMap_dart_const_iterator_of_cell<CMap,i> it(amap, adart);
|
||||
res && it.cont(); ++it )
|
||||
|
|
|
|||
|
|
@ -156,7 +156,7 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
protected:
|
||||
/** Default constructor: no real initialisation,
|
||||
/** Default constructor: no real initialization,
|
||||
* because this is done in the combinatorial map class.
|
||||
*/
|
||||
Dart_without_info()
|
||||
|
|
@ -300,7 +300,7 @@ namespace CGAL {
|
|||
{ return Base::operator==(other) && minfo==other.minfo; }
|
||||
|
||||
protected:
|
||||
/** Default constructor: no real initialisation,
|
||||
/** Default constructor: no real initialization,
|
||||
* because this is done in the combinatorial or generalized map class.
|
||||
*/
|
||||
Dart()=default; // default => zero-initializing built-in types
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ public:
|
|||
|
||||
#if defined(CGAL_USE_LEDA) || defined(CGAL_USE_CORE)
|
||||
/*
|
||||
The specialised functor for computing the directions of cone boundaries exactly
|
||||
The specialized functor for computing the directions of cone boundaries exactly
|
||||
with a given cone number and a given initial direction.
|
||||
*/
|
||||
template <>
|
||||
|
|
|
|||
|
|
@ -199,7 +199,7 @@ protected:
|
|||
std::vector<typename Graph_::vertex_descriptor> S(vit, ve);
|
||||
std::sort(S.begin (), S.end (), orderD1);
|
||||
|
||||
// Step 2: Initialise an empty set to store vertices sorted by orderD2
|
||||
// Step 2: initialize an empty set to store vertices sorted by orderD2
|
||||
typedef CGAL::ThetaDetail::Plane_scan_tree<typename Graph_::vertex_descriptor,
|
||||
typename Graph_::vertex_descriptor,
|
||||
Less_by_direction,
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ protected:
|
|||
std::vector<typename Graph_::vertex_descriptor> S(vit, ve);
|
||||
std::sort(S.begin (), S.end (), orderD1);
|
||||
|
||||
// Step 2: Initialise an empty set to store vertices sorted by orderD2
|
||||
// Step 2: initialize an empty set to store vertices sorted by orderD2
|
||||
Point_set pst(orderD2);
|
||||
|
||||
// Step 3: visit S in orderD1
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ std::string gnuplot_vertex_list (const Graph& g);
|
|||
|
||||
/* This struct is defined to use partial specialization to generate arrow styles differently for
|
||||
* directed and undirected graphs.
|
||||
* Note: Need to use structs because C++ before 11 doesn't allow partial specialisation
|
||||
* Note: Need to use structs because C++ before 11 doesn't allow partial specialization
|
||||
* for functions
|
||||
*/
|
||||
template <typename Graph, typename Directedness=typename Graph::directed_selector>
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ configuration.
|
|||
create <B>a single executable</B> for 'source' linked with
|
||||
compilations of all other source files
|
||||
(`*.cc`, `*.cp`, `*.cxx`, `*.cpp`, `*.CPP`, `*.c++`, or `*.C`).
|
||||
This behaviour is usually needed for (graphical) demos.
|
||||
This behavior is usually needed for (graphical) demos.
|
||||
|
||||
If the parameter is not given, the script creates <B>one executable for each given
|
||||
source file</B>.
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ also avoid CMake to link with the native threads support library on your system.
|
|||
|
||||
Much of the \cgal code contains assert statements for preconditions, and postconditions of functions
|
||||
as well as in the code. These assertions can be switched on and off per package
|
||||
and the user can change the error behaviour. For details see Section \ref secchecks
|
||||
and the user can change the error behavior. For details see Section \ref secchecks
|
||||
of Chapter \ref Chapter_STL_Extensions_for_CGAL.
|
||||
|
||||
\section Preliminaries_flags Compile-time Flags to Control Inlining
|
||||
|
|
|
|||
|
|
@ -193,7 +193,7 @@ An example of a raster image with a rainbow ramp representing height
|
|||
is given in \cgalFigureRef{TutorialGISFigRastering}.
|
||||
|
||||
\cgalFigureBegin{TutorialGISFigRastering, raster.jpg}
|
||||
Raster visualisation of height using a rainbow ramp, ranging from
|
||||
Raster visualization of height using a rainbow ramp, ranging from
|
||||
light blue for low values to dark red for high values.
|
||||
\cgalFigureEnd
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ other contexts can be done by obtaining a commercial license from
|
|||
[GeometryFactory](https://www.geometryfactory.com). For more details
|
||||
see the \ref license "License" page.
|
||||
|
||||
<h2>Acknowledgement</h2>
|
||||
<h2>Acknowledgment</h2>
|
||||
|
||||
We provide bibtex entries for each package so that you can cite \cgal correctly in your publications,
|
||||
see the page \ref how_to_cite_cgal.
|
||||
|
|
|
|||
|
|
@ -1377,7 +1377,7 @@ struct Ith {
|
|||
typedef T2 result_type;
|
||||
|
||||
// We keep a Sign member object
|
||||
// for future utilisation, in case
|
||||
// for future utilization, in case
|
||||
// we have pairs of 2 T2 objects e.g.
|
||||
// for a numeric_point vector returned
|
||||
// from a construction of a possible
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ namespace CGAL {
|
|||
* - GMap_cell_iterator<Map,i,dim>: one dart per each i-cell
|
||||
* - GMap_one_dart_per_incident_cell_iterator<Map,Ite,i,dim>
|
||||
* - GMap_one_dart_per_cell_iterator<Map,Ite,i,dim>
|
||||
* - one specialisation of the CMap_cell_iterator for the
|
||||
* - one specialization of the CMap_cell_iterator for the
|
||||
* GMap_dart_iterator_basic_of_all iterator
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -249,7 +249,7 @@ namespace CGAL {
|
|||
class GMap_dart_iterator_basic_of_two_alpha;
|
||||
/* Class CMap_dart_iterator_basic_of_two_alpha<Ai,1>: to iterate
|
||||
* on the darts of the orbit <Ai,Ai+1>: Ai<Ai+1<=dimension.
|
||||
* specialisation because here Aio(Ai+1) is not an involution.
|
||||
* specialization because here Aio(Ai+1) is not an involution.
|
||||
* Basic classes do not guaranty correct marks (i.e. do not unmark darts in
|
||||
* the destructor, possible problem with the rewind). If you are not sure,
|
||||
* use CMap_dart_iterator_basic_of_two_alpha.
|
||||
|
|
|
|||
|
|
@ -568,7 +568,7 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
/** Create a new dart and add it to the map.
|
||||
* The marks of the darts are initialised with mmask_marks, i.e. the dart
|
||||
* The marks of the darts are initialized with mmask_marks, i.e. the dart
|
||||
* is unmarked for all the marks.
|
||||
* @return a Dart_descriptor on the new dart.
|
||||
*/
|
||||
|
|
@ -3352,7 +3352,7 @@ namespace CGAL {
|
|||
}
|
||||
if (ah != null_descriptor)
|
||||
{
|
||||
// We initialise the 0-atttrib to ah
|
||||
// We initialize the 0-atttrib to ah
|
||||
CGAL::internal::Set_i_attribute_of_dart_functor<Self, 0>::
|
||||
run(*this, d1, ah);
|
||||
mark(*it, amark);
|
||||
|
|
@ -3471,7 +3471,7 @@ namespace CGAL {
|
|||
<CGAL::internal::GMap_group_attribute_functor_of_dart<Self>, 0>::
|
||||
run(*this,d1,d2);
|
||||
|
||||
// We initialise the 0-atttrib to ah
|
||||
// We initialize the 0-atttrib to ah
|
||||
CGAL::internal::Set_i_attribute_of_dart_functor<Self, 0>::
|
||||
run(*this, d2, ah);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ namespace CGAL
|
|||
{
|
||||
static bool run(const GMap& amap, typename GMap::Dart_const_descriptor adart)
|
||||
{
|
||||
// TODO? Optimisation for dim-2, and to not test all the darts of the cell?
|
||||
// TODO? Optimization for dim-2, and to not test all the darts of the cell?
|
||||
bool res = true;
|
||||
for ( CGAL::GMap_dart_const_iterator_of_cell<GMap,i> it(amap, adart);
|
||||
res && it.cont(); ++it )
|
||||
|
|
@ -258,7 +258,7 @@ namespace CGAL
|
|||
{
|
||||
static bool run(const GMap& amap, typename GMap::Dart_const_descriptor adart)
|
||||
{
|
||||
// TODO ? Optimisation possible to not test all the darts of the cell ?
|
||||
// TODO ? Optimization possible to not test all the darts of the cell ?
|
||||
bool res = true;
|
||||
for ( CGAL::GMap_dart_const_iterator_of_cell<GMap,i> it(amap, adart);
|
||||
res && it.cont(); ++it )
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ a <I>state</I> that uniquely determines the subsequent numbers being
|
|||
produced.
|
||||
|
||||
It can be very useful, e.g. for debugging, to reproduce a sequence of
|
||||
random numbers. This can be done by either initialising with a fixed
|
||||
random numbers. This can be done by either initializing with a fixed
|
||||
seed, or by using the state functions as described below.
|
||||
|
||||
\note A `Random` object is not deterministic when used by several threads at
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ public:
|
|||
const double& size() const { return second; }
|
||||
const double& sine() const { return first; }
|
||||
|
||||
// q1<q2 means q1 is prioritised over q2
|
||||
// q1<q2 means q1 is prioritized over q2
|
||||
// ( q1 == *this, q2 == q )
|
||||
bool operator<(const Quality& q) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1225,7 +1225,7 @@ Vec Camera::pivotPoint() const { return frame()->pivotPoint(); }
|
|||
/*! Sets the Camera's position() and orientation() from an OpenGL ModelView
|
||||
matrix.
|
||||
|
||||
This enables a Camera initialisation from an other OpenGL application. \p
|
||||
This enables a Camera initialization from an other OpenGL application. \p
|
||||
modelView is a 16 GLdouble vector representing a valid OpenGL ModelView matrix,
|
||||
such as one can get using: \code GLdouble mvm[16];
|
||||
glGetDoublev(GL_MODELVIEW_MATRIX, mvm);
|
||||
|
|
|
|||
|
|
@ -604,7 +604,7 @@ public:
|
|||
|
||||
// This guard is needed here because, rr==ll==begin, might be true
|
||||
// at this point, causing the decrement to result in undefined
|
||||
// behaviour.
|
||||
// behavior.
|
||||
// [Fernando Cacciola]
|
||||
if ( ll < rr )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1915,7 +1915,7 @@ Release date: April 2018
|
|||
after the observer is notified that the edge has been removed. This is
|
||||
symmetric (opposite) to the order of notification when an edge is inserted.
|
||||
|
||||
The user can restore old (non-symmetric) behaviour by defining the macro:
|
||||
The user can restore old (non-symmetric) behavior by defining the macro:
|
||||
|
||||
`CGAL_NON_SYMETRICAL_OBSERVER_EDGE_REMOVAL_BACKWARD_COMPATIBILITY`
|
||||
|
||||
|
|
@ -3456,7 +3456,7 @@ Release date: October 2013
|
|||
vertices which would move of very small displacements.
|
||||
- Introduce new data structures and options for speed-up and
|
||||
compacity. Note that `Compact_mesh_cell_base_3` and
|
||||
`Mesh_vertex_base_3` are now our favoured implementations of the
|
||||
`Mesh_vertex_base_3` are now our favored implementations of the
|
||||
concepts MeshCellBase\_3 and MeshVertexBase\_3.
|
||||
- Introduce a new constructor for `Polyhedral_mesh_domain_3` that
|
||||
takes a bounding polyhedron to be meshed along with a polyhedral
|
||||
|
|
@ -4567,9 +4567,9 @@ fixes for this release.
|
|||
- The new macro CGAL\_NO\_DEPRECATED\_CODE can be defined to disable
|
||||
deprecated code, helping users discover if they rely on code that
|
||||
may be removed in subsequent releases.
|
||||
- Assertion behaviour: It is not possible anymore to set the CONTINUE
|
||||
- Assertion behavior: It is not possible anymore to set the CONTINUE
|
||||
mode for assertion failures. Functions that allow to change the
|
||||
assertion behaviour are now declared in
|
||||
assertion behavior are now declared in
|
||||
`<CGAL/assertions_behaviour.h>`.
|
||||
- Qt3 based demos are still there but the documentation has been
|
||||
removed as the CGAL::Qt\_Widget will be deprecated.
|
||||
|
|
@ -5118,7 +5118,7 @@ static runtime (/ML).
|
|||
- 2D Placement of Streamlines (new package)
|
||||
Visualizing vector fields is important for many application domains.
|
||||
A good way to do it is to generate streamlines that describe the
|
||||
flow behaviour. This package implements the "Farthest Point Seeding"
|
||||
flow behavior. This package implements the "Farthest Point Seeding"
|
||||
algorithm for placing streamlines in 2D vector fields. It generates
|
||||
a list of streamlines corresponding to an input flow using a
|
||||
specified separating distance. The algorithm uses a Delaunay
|
||||
|
|
@ -5140,7 +5140,7 @@ static runtime (/ML).
|
|||
structures. The package supports exact or inexact operations on
|
||||
primitives which move along polynomial trajectories.
|
||||
- Smallest Enclosing Ellipsoid (new package)
|
||||
This algorithm is new in the chapter Geometric Optimisation.
|
||||
This algorithm is new in the chapter Geometric Optimization.
|
||||
- 2D Arrangement (major revision)
|
||||
This package can be used to construct, maintain, alter, and display
|
||||
arrangements in the plane. Once an arrangement is constructed, the
|
||||
|
|
@ -5155,9 +5155,9 @@ static runtime (/ML).
|
|||
construction history of the arrangement, such that it is possible to
|
||||
obtain the originating curve of an arrangement subcurve.
|
||||
|
||||
- Geometric Optimisation (major revision)
|
||||
- Geometric Optimization (major revision)
|
||||
The underlying QP solver which is the foundation for several
|
||||
algorithms in the Geometric Optimisation chapter has been completely
|
||||
algorithms in the Geometric Optimization chapter has been completely
|
||||
rewritten.
|
||||
- 3D Triangulation (new functionality)
|
||||
Regular\_triangulation\_3 now offers vertex removal.
|
||||
|
|
@ -5483,7 +5483,7 @@ The following functionality has been added or changed:
|
|||
Face\_handle or Vertex\_handle.
|
||||
- New classes Triangulation\_vertex\_base\_with\_info\_2 (and 3)
|
||||
and Triangulation\_face\_base\_with\_info\_2 (and 3) to make
|
||||
easier the customisation of base classes in most cases.
|
||||
easier the customization of base classes in most cases.
|
||||
- 2D Triangulation
|
||||
- Regular triangulation provides an easy access to hidden points.
|
||||
- The Triangulation\_hierarchy\_2, which provide an efficient
|
||||
|
|
@ -5985,7 +5985,7 @@ kernels themselves can be used as traits classes in many instances.
|
|||
- The traits class requirements have been changed.
|
||||
- The simplicity test has a completely new implementation.
|
||||
- Properties like convexity, simplicity and area can now be cached
|
||||
by polygons. You need to set a flag to select this behaviour.
|
||||
by polygons. You need to set a flag to select this behavior.
|
||||
|
||||
|
||||
|
||||
|
|
@ -6158,7 +6158,7 @@ The following functionality has been added:
|
|||
stored within a class, debugging is easier using this kernel. This
|
||||
kernel can also be faster in some cases than the reference-counted
|
||||
Cartesian kernel.
|
||||
- New optimisation algorithms
|
||||
- New optimization algorithms
|
||||
- Min\_annulus\_d - Algorithm for computing the smallest enclosing
|
||||
annulus of points in arbitrary dimension
|
||||
- Polytope\_distance\_d - Algorithm for computing the (squared)
|
||||
|
|
@ -6215,7 +6215,7 @@ The following functionality has been added:
|
|||
triangulations.
|
||||
- Triangulations in 3D were added, both Delaunay triangulations and
|
||||
regular triangulations.
|
||||
- Min\_quadrilateral optimisations have been added. These are
|
||||
- Min\_quadrilateral optimizations have been added. These are
|
||||
algorithms to compute the minimum enclosing rectangle/parallelogram
|
||||
(arbitrary orientation) and the minimum enclosing strip of a convex
|
||||
point set.
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
//
|
||||
// Author(s) : Andreas Fabri
|
||||
//
|
||||
// Warning: this file is generated, see include/CGAL/licence/README.md
|
||||
// Warning: this file is generated, see include/CGAL/license/README.md
|
||||
// not entirely true due to the backward compatibility issue
|
||||
|
||||
#ifndef CGAL_LICENSE_POLYGON_MESH_PROCESSING_COMBINATORIAL_REPAIR_H
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ protected:
|
|||
// typedef typename boost::property_traits<VertexPropertyMap>::value_type vpm_value_type;
|
||||
// typedef typename boost::property_traits<VertexPropertyMap>::key_type vpm_key_type;
|
||||
|
||||
//vertex indices are initialised to -1
|
||||
//vertex indices are initialized to -1
|
||||
static void reset_ring_indices(std::vector < Vertex * >&vces,
|
||||
VertexPropertyMap& vpm);
|
||||
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@
|
|||
<item row="3" column="0">
|
||||
<widget class="QLabel" name="runLloyd_label">
|
||||
<property name="text">
|
||||
<string>Run Lloyd Optimisation</string>
|
||||
<string>Run Lloyd Optimization</string>
|
||||
</property>
|
||||
<property name="alignment">
|
||||
<set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
|
||||
|
|
|
|||
|
|
@ -280,7 +280,7 @@ private:
|
|||
|
||||
//according to the tag, a,b,c dim change but not the scale. We look for the max dimension of the whole image.
|
||||
//A high scale factor will often go with a low dimension, to compensate it. So we don't want a max being the
|
||||
//higher scale * the higher dim, hence the tag specialisation.
|
||||
//higher scale * the higher dim, hence the tag specialization.
|
||||
//TODO: set the scale factors according to the dimensipon to avoid doing that.
|
||||
double compute_maxDim(x_tag) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -144,15 +144,15 @@ protected:
|
|||
void paintEvent(QPaintEvent *)override;
|
||||
void paintGL()override;
|
||||
|
||||
//!Defines the behaviour for the mouse press events
|
||||
//!Defines the behavior for the mouse press events
|
||||
void mousePressEvent(QMouseEvent*)override;
|
||||
void mouseDoubleClickEvent(QMouseEvent*)override;
|
||||
void wheelEvent(QWheelEvent *)override;
|
||||
//!Defines the behaviour for the key press events
|
||||
//!Defines the behavior for the key press events
|
||||
void keyPressEvent(QKeyEvent*)override;
|
||||
//!Deal with context menu events
|
||||
void contextMenuEvent(QContextMenuEvent*)override;
|
||||
//!Defines the behaviour for the key release events
|
||||
//!Defines the behavior for the key release events
|
||||
void keyReleaseEvent(QKeyEvent *)override;
|
||||
|
||||
protected:
|
||||
|
|
|
|||
|
|
@ -2780,7 +2780,7 @@ void MainWindow::sierpinski_carpet_copy_attributes_and_embed_vertex
|
|||
LCC::Helper::Foreach_enabled_attributes_except
|
||||
<CGAL::internal::Group_attribute_functor_of_dart<LCC>, 0>::
|
||||
run(*(scene.lcc),sierpinskiCarpetSurfaces[0],it);
|
||||
// We initialise the 0-atttrib to ah
|
||||
// We initialize the 0-atttrib to ah
|
||||
scene.lcc->set_dart_attribute<0>(it, ah);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -252,7 +252,7 @@ Before applying the sew operation, the eight vertices of the first cube are colo
|
|||
\subsection Linear_cell_complexAutomaticAttributesManagement Automatic Attribute Management
|
||||
\anchor ssecAttributesManagement
|
||||
|
||||
The following example illustrates the use of the automatic attributes management for a linear cell complex. An off file is loaded into a 2D linear cell complex embedded in 3D. Then, a certain percentage of edges is removed from the linear cell complex. The same method is applied twice: the first time by using the automatic attributes management (which is the default behaviour) and the second time by calling first \link GenericMap::set_automatic_attributes_management `set_automatic_attributes_management(false)`\endlink to disable the automatic updating of attributes.
|
||||
The following example illustrates the use of the automatic attributes management for a linear cell complex. An off file is loaded into a 2D linear cell complex embedded in 3D. Then, a certain percentage of edges is removed from the linear cell complex. The same method is applied twice: the first time by using the automatic attributes management (which is the default behavior) and the second time by calling first \link GenericMap::set_automatic_attributes_management `set_automatic_attributes_management(false)`\endlink to disable the automatic updating of attributes.
|
||||
|
||||
We can observe that the second run is faster than the first one. Indeed, updating attribute for each edge removal give a bigger complexity. Moreover, the gain increases when the percentage of removed edges increases.
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ namespace CGAL {
|
|||
`monotone_matrix_search()` and `sorted_matrix_search()`
|
||||
are techniques that deal with the problem of efficiently finding
|
||||
largest entries in matrices with certain structural properties. Many
|
||||
concrete problems can be modelled as matrix search problems, and for
|
||||
concrete problems can be modeled as matrix search problems, and for
|
||||
some of them we provide explicit solutions that allow you to solve
|
||||
them without knowing about the matrix search technique. Examples are,
|
||||
the computation of all furthest neighbors for the vertices of a convex
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ public:
|
|||
const double& size() const { return second; }
|
||||
const double& sine() const { return first; }
|
||||
|
||||
// q1<q2 means q1 is prioritised over q2
|
||||
// q1<q2 means q1 is prioritized over q2
|
||||
// ( q1 == *this, q2 == q )
|
||||
bool operator<(const Quality& q) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ def main(argv):
|
|||
cell_scan_time = parse_xml_file(xml_filename, "Cells_scan_time")
|
||||
cell_refine_time = parse_xml_file(xml_filename, "Cells_refine_time")
|
||||
|
||||
# Optimisation
|
||||
# Optimization
|
||||
lloyd_optim_time = parse_xml_file(xml_filename, "Lloyd_optim_time")
|
||||
odt_optim_time = parse_xml_file(xml_filename, "Odt_optim_time")
|
||||
perturber_optim_time = parse_xml_file(xml_filename, "Perturber_optim_time")
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ struct Slivers_ex_att_t_aux<Cell, true>
|
|||
{
|
||||
return c->slivers_exuder_restore_attributes(attr);
|
||||
}
|
||||
}; // end partial specialisation Slivers_ex_att_t_aux<Cell, true>
|
||||
}; // end partial specialization Slivers_ex_att_t_aux<Cell, true>
|
||||
|
||||
template <class Cell>
|
||||
struct Slivers_exuder_cell_attributes_traits
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@
|
|||
|
||||
//#define CGAL_MESH_3_VERBOSE 1
|
||||
|
||||
// Use optimisations of Mesh_3
|
||||
// Use optimizations of Mesh_3
|
||||
# define CGAL_CONSTRUCT_INTRUSIVE_LIST_RANGE_CONSTRUCTOR 1
|
||||
# define CGAL_MESH_3_NEW_GET_FACETS 1
|
||||
# define CGAL_MESH_3_GET_FACETS_USING_INTRUSIVE_LIST 1
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ public:
|
|||
/**
|
||||
* @brief General traversal query
|
||||
* @param query the query
|
||||
* @param traits the traversal traits that define the traversal behaviour
|
||||
* @param traits the traversal traits that define the traversal behavior
|
||||
* @param nb_primitives the number of primitive
|
||||
*
|
||||
* General traversal query. The traits class allows using it for the various
|
||||
|
|
@ -79,7 +79,7 @@ public:
|
|||
|
||||
/**
|
||||
* @param other_node root node of a tree which we want to traverse in parallel
|
||||
* @param traits the traversal traits that define the traversal behaviour
|
||||
* @param traits the traversal traits that define the traversal behavior
|
||||
* @param nb_primitives the number of primitives in this tree
|
||||
* @param nb_primitives_other the number of primitives in the other tree
|
||||
* @param first_stationary if true, the other_node is the translatable tree's root
|
||||
|
|
|
|||
|
|
@ -536,7 +536,7 @@ protected:
|
|||
The efficiency of this point location module is mostly based on
|
||||
heuristics. Therefore worst case bounds are not very expressive. The
|
||||
query operations take up to linear time for subsequent query
|
||||
operations though they are better in practise. They trigger a one-time
|
||||
operations though they are better in practize. They trigger a one-time
|
||||
initialization which needs worst case $O(n^2)$ time though runtime
|
||||
tests often show subquadratic results. The necessary space for the
|
||||
query structure is subsumed in the storage space $O(n)$ of the input
|
||||
|
|
|
|||
|
|
@ -320,7 +320,7 @@ class PointLocator {
|
|||
If the ray does not intersect any node or edge of |G|, then |nil| is
|
||||
returned.\\
|
||||
The class |\Mtype| is generic, it is parameterized with a traits class
|
||||
|PLocTraits| which widely controls its behaviour.
|
||||
|PLocTraits| which widely controls its behavior.
|
||||
The traits may even change the return type of a query and its semantics.
|
||||
There are predined traits classes for the LEDA graph types, which are
|
||||
described below in a separate section.
|
||||
|
|
|
|||
|
|
@ -420,7 +420,7 @@ the symbolical value, large but finite, for the size of the infimaximal box.
|
|||
|
||||
\subsection Nef_3DrawNefPolyhedron Draw a Nef Polyhedron
|
||||
|
||||
A nef polyhedron can be visualised by calling the \link PkgDrawNef3 CGAL::draw<Nef_3>() \endlink function as shown in the following example. This function opens a new window showing the given Nef Polyhedron.
|
||||
A nef polyhedron can be visualized by calling the \link PkgDrawNef3 CGAL::draw<Nef_3>() \endlink function as shown in the following example. This function opens a new window showing the given Nef Polyhedron.
|
||||
|
||||
\cgalExample{Nef_3/draw_nef_3.cpp}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ All interval operations are performed by the \mpfi library. The class `Gmpfi` is
|
|||
counted, but its members are.
|
||||
|
||||
The default precision of `Gmpfi` is local to each thread and independent of
|
||||
the default precision of `Gmpfr` (in contrast to the behaviour of the \mpfi
|
||||
the default precision of `Gmpfr` (in contrast to the behavior of the \mpfi
|
||||
and \mpfr libraries,
|
||||
which share a default precision).
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ template <class COEFF, class ROOT, class ACDE_TAG,class FP_TAG>
|
|||
class Algebraic_extension_traits<CGAL::Sqrt_extension<COEFF,ROOT,ACDE_TAG,FP_TAG> > {
|
||||
/* needed to 'add up' sqrt_extensions in iterator range such that all roots
|
||||
are collected in order to keep operation time minimal all scalar coeffs
|
||||
are set to 1 by standardise.
|
||||
are set to 1 by standardize.
|
||||
TODO .. find a better name, if you want to.
|
||||
*/
|
||||
template <class Type_>
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ namespace Intern{
|
|||
|
||||
/*! \ingroup CGAL_Sqrt_extension
|
||||
\ingroup CGAL_Fraction_traits_spec
|
||||
\brief Specialisation of CGAL::Fraction_traits for CGAL::Sqrt_extension.
|
||||
\brief Specialization of CGAL::Fraction_traits for CGAL::Sqrt_extension.
|
||||
*
|
||||
* Extensions provide suitable specializations of \c CGAL::Fraction_traits.
|
||||
* They are decomposable iff their coefficient type is.
|
||||
|
|
|
|||
|
|
@ -301,7 +301,7 @@ namespace Boost_MP_internal {
|
|||
const int64_t msb_num = static_cast<int64_t>(boost::multiprecision::msb(xnum));
|
||||
const int64_t msb_den = static_cast<int64_t>(boost::multiprecision::msb(xden));
|
||||
|
||||
#if 0 // Optimisation for the case of input that are double
|
||||
#if 0 // Optimization for the case of input that are double
|
||||
// An alternative strategy would be to convert numerator and denominator to
|
||||
// intervals, then divide. However, this would require setting the rounding
|
||||
// mode (and dividing intervals is not completely free). An important
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ template <> class Algebraic_structure_traits< leda_integer >
|
|||
CGAL_IMPLICIT_INTEROPERABLE_BINARY_OPERATOR( Type )
|
||||
};
|
||||
|
||||
// Unfortunately the behaviour of leda has changed here several times
|
||||
// Unfortunately the behavior of leda has changed here several times
|
||||
// The following Div_mod is invariant under these changes
|
||||
// However, the Div and Mod defined below might be more efficient
|
||||
// TODO: recover Div Mod implementation for all leda versions
|
||||
|
|
|
|||
|
|
@ -575,7 +575,7 @@ void test_algebraic_extension_traits(){
|
|||
typedef CGAL::Sqrt_extension<RAT1_EXT,INT,ACDE_TAG> RAT2_EXT;
|
||||
typedef CGAL::Sqrt_extension<INT1_EXT,INT,ACDE_TAG> INT2_EXT;
|
||||
|
||||
// normalisation factor
|
||||
// normalization factor
|
||||
typedef CGAL::Algebraic_extension_traits<RAT1_EXT> RAT1_EXT_ANT;
|
||||
typedef CGAL::Algebraic_extension_traits<INT1_EXT> INT1_EXT_ANT;
|
||||
typedef CGAL::Algebraic_extension_traits<RAT2_EXT> RAT2_EXT_ANT;
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Basic stuff for geometric optimisation
|
||||
Basic stuff for geometric optimization
|
||||
|
|
|
|||
|
|
@ -1410,7 +1410,7 @@ public:
|
|||
}
|
||||
|
||||
void dump_box_to_polylines(const Bbox_2& box, std::ostream& os) const {
|
||||
// dump in 3D for visualisation
|
||||
// dump in 3D for visualization
|
||||
os << "5 "
|
||||
<< box.xmin() << " " << box.ymin() << " 0 "
|
||||
<< box.xmin() << " " << box.ymax() << " 0 "
|
||||
|
|
|
|||
|
|
@ -2211,7 +2211,7 @@ Gt, Tds >::insert_first(const Point& p)
|
|||
/// Virtual faces, two per periodic domain
|
||||
Face_handle faces[3][3][2];
|
||||
|
||||
// Initialise vertices:
|
||||
// initialize vertices:
|
||||
vir_vertices[0][0] = _tds.create_vertex();
|
||||
vir_vertices[0][0]->set_point(p);
|
||||
_virtual_vertices_reverse[vir_vertices[0][0]] = std::vector<Vertex_handle>();
|
||||
|
|
@ -2221,7 +2221,7 @@ Gt, Tds >::insert_first(const Point& p)
|
|||
{
|
||||
if ((i != 0) || (j != 0))
|
||||
{
|
||||
// Initialise virtual vertices out of the domain for debugging
|
||||
// initialize virtual vertices out of the domain for debugging
|
||||
vir_vertices[i][j] = _tds.create_vertex();
|
||||
vir_vertices[i][j]->set_point(p); //+Offset(i,j));
|
||||
_virtual_vertices[vir_vertices[i][j]] = Virtual_vertex(
|
||||
|
|
|
|||
|
|
@ -25,12 +25,12 @@ Periodic_2_triangulation_2<GT, Tds>::insert_dummy_points()
|
|||
// 6 faces per row, 4 rows
|
||||
Face_handle faces[24];
|
||||
|
||||
// Initialise vertices:
|
||||
// initialize vertices:
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
for (int j = 0; j < 3; j++)
|
||||
{
|
||||
// Initialise virtual vertices out of the domain for debugging
|
||||
// initialize virtual vertices out of the domain for debugging
|
||||
vertices[3 * i + j] = _tds.create_vertex();
|
||||
Point p(j * (1.0 / 3.0) + i * (1.0 / 6.0), i * (1.0 / 4.0) );
|
||||
p = Point((p.x() > FT(0.9375) ? (std::max)( p.x() - 1, FT(0) ) : p.x()),
|
||||
|
|
|
|||
|
|
@ -1190,7 +1190,7 @@ Protect_edges_sizing_field<C3T3, MD, Sf>::
|
|||
try_to_move_dummy_vertex(const Vertex_handle dummy_vertex,
|
||||
const Weighted_point& new_position)
|
||||
{
|
||||
// Insert first to maximise likeliness of success
|
||||
// Insert first to maximize likeliness of success
|
||||
Vertex_handle new_dummy = insert_dummy_point(new_position);
|
||||
|
||||
if(!try_to_remove_dummy_vertex(dummy_vertex))
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@
|
|||
// memory boolean in the vertex base
|
||||
#define CGAL_PERIODIC_TRIANGULATION_USE_VISITED_VERTEX_BOOLEAN
|
||||
|
||||
// Avoid optimisations of Mesh_3
|
||||
// Avoid optimizations of Mesh_3
|
||||
#define CGAL_NO_STRUCTURAL_FILTERING
|
||||
#ifdef CGAL_MESH_3_SIZING_FIELD_INEXACT_LOCATE
|
||||
#undef CGAL_MESH_3_SIZING_FIELD_INEXACT_LOCATE
|
||||
|
|
|
|||
|
|
@ -2784,7 +2784,7 @@ Periodic_3_triangulation_3<GT,TDS>::create_initial_triangulation(const Point& p)
|
|||
/// Virtual cells, 6 per periodic instance
|
||||
Cell_handle cells[3][3][3][6];
|
||||
|
||||
// Initialise vertices:
|
||||
// initialize vertices:
|
||||
vir_vertices[0][0][0] = _tds.create_vertex();
|
||||
vir_vertices[0][0][0]->set_point(p);
|
||||
virtual_vertices_reverse[vir_vertices[0][0][0]] = std::vector<Vertex_handle>();
|
||||
|
|
@ -2792,7 +2792,7 @@ Periodic_3_triangulation_3<GT,TDS>::create_initial_triangulation(const Point& p)
|
|||
for(int j=0; j<_cover[1]; j++) {
|
||||
for(int k=0; k<_cover[2]; k++) {
|
||||
if((i!=0)||(j!=0)||(k!=0)) {
|
||||
// Initialise virtual vertices out of the domain for debugging
|
||||
// initialize virtual vertices out of the domain for debugging
|
||||
vir_vertices[i][j][k] =
|
||||
_tds.create_vertex();
|
||||
vir_vertices[i][j][k]->set_point(p); //+Offset(i,j,k));
|
||||
|
|
|
|||
|
|
@ -682,11 +682,11 @@ static const int O[216][4] = {
|
|||
Vertex_handle vertices[36];
|
||||
Cell_handle cells[216];
|
||||
|
||||
// Initialise vertices:
|
||||
// initialize vertices:
|
||||
for (int i=0; i<4; i++) {
|
||||
for (int j=0; j<3; j++) {
|
||||
for (int k=0; k<3; k++) {
|
||||
// Initialise virtual vertices out of the domain for debugging
|
||||
// initialize virtual vertices out of the domain for debugging
|
||||
vertices[9*i+3*j+k] = _tds.create_vertex();
|
||||
Point p(k*(1.0/3.0) + i*(1.0/6.0),
|
||||
j*(1.0/3.0) + i*(1.0/6.0), i*(1.0/4.0) );
|
||||
|
|
|
|||
|
|
@ -264,7 +264,7 @@ test_filtration(AS &A, bool verbose)
|
|||
typename AS::NT alpha;
|
||||
if(verbose) {
|
||||
std::cerr << std::endl;
|
||||
std::cerr << "Analyse filtration " << std::endl;
|
||||
std::cerr << "Analyze filtration " << std::endl;
|
||||
}
|
||||
for (; filtre_it != filtration.end(); filtre_it++) {
|
||||
if(assign(vertex, *filtre_it)) {
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ public:
|
|||
double sq_size() const { return second; }
|
||||
double aspect() const { return first; }
|
||||
|
||||
// q1<q2 means q1 is prioritised over q2
|
||||
// q1<q2 means q1 is prioritized over q2
|
||||
// ( q1 == *this, q2 == q )
|
||||
bool operator<(const Cell_quality& q) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -369,7 +369,7 @@ int which_side_in_slab(Point const &point, Point const &low, Point const &high,
|
|||
// precondition: low.y < point.y < high.y
|
||||
{
|
||||
// first we try to decide on x coordinate values alone
|
||||
// This is an optimisation (whether this is really faster for
|
||||
// This is an optimization (whether this is really faster for
|
||||
// a homogeneous kernel is not clear, as comparisons can be expensive.
|
||||
Comparison_result low_x_comp_res = compare_x_2(point, low);
|
||||
Comparison_result high_x_comp_res = compare_x_2(point, high);
|
||||
|
|
|
|||
|
|
@ -1496,7 +1496,7 @@ void autorefine_triangle_soup(PointRange& soup_points,
|
|||
std::string mode = "parallel";
|
||||
#endif
|
||||
|
||||
// It might be possible to optimise the hardcoded value below
|
||||
// It might be possible to optimize the hardcoded value below
|
||||
// but the less triangles the faster will anyway be the operation.
|
||||
// So it's probably not critical.
|
||||
#ifdef CGAL_LINKED_WITH_TBB
|
||||
|
|
|
|||
|
|
@ -619,7 +619,7 @@ compute_vertex_normal_as_sum_of_weighted_normals(typename boost::graph_traits<Po
|
|||
* \brief computes the unit normal at vertex `v` as a function of the normals of incident faces.
|
||||
*
|
||||
* The implementation is inspired by Aubry et al. "On the most 'normal' normal" \cgalCite{cgal:al-otmnn-08},
|
||||
* which aims to compute a normal that maximises the visibility to the incident faces.
|
||||
* which aims to compute a normal that maximizes the visibility to the incident faces.
|
||||
* If such normal does not exist or if the optimization process fails to find it, a fallback normal is computed
|
||||
* as a sine-weighted sum of the normals of the incident faces.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1485,7 +1485,7 @@ bounded_error_squared_Hausdorff_distance_impl(const TriangleMesh1& tm1,
|
|||
TM1_hd_traits traversal_traits_tm1(tm2_tree, tm1, tm2, vpm1, vpm2,
|
||||
infinity_value, sq_initial_bound, sq_distance_bound);
|
||||
|
||||
// Find candidate triangles in TM1, which might realise the Hausdorff bound.
|
||||
// Find candidate triangles in TM1, which might realize the Hausdorff bound.
|
||||
// We build a sorted structure while collecting the candidates.
|
||||
const Point_3 stub(0, 0, 0); // dummy point given as query since it is not needed
|
||||
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ public:
|
|||
//check if the ray source is above or below the triangle and compare it
|
||||
//with the direction of the ray
|
||||
//TODO and if yes return
|
||||
//this is just an optimisation, the current code is valid
|
||||
//this is just an optimization, the current code is valid
|
||||
|
||||
this->m_status.first=boost::logic::indeterminate;
|
||||
this->m_stop=true;
|
||||
|
|
|
|||
|
|
@ -582,7 +582,7 @@ struct Filter_wrapper_for_cap_needle_removal<TriangleMesh, VPM, Traits, Identity
|
|||
/// \cgalParamNBegin{filter}
|
||||
/// \cgalParamDescription{A function object providing `bool operator()(geom_traits::Point_3,geom_traits::Point_3,geom_traits::Point_3)`.}
|
||||
/// \cgalParamType{The function object is queried each time a new triangle is about to be created by a flip or a collapse operation.
|
||||
/// If `false` is returned, the operation is cancelled.}
|
||||
/// If `false` is returned, the operation is canceled.}
|
||||
/// \cgalParamDefault{a functor always returning `true`.}
|
||||
/// \cgalParamNEnd
|
||||
/// \cgalNamedParamsEnd
|
||||
|
|
|
|||
|
|
@ -172,7 +172,7 @@ symmetric_bezout_matrix
|
|||
|
||||
Matrix B(d);
|
||||
|
||||
// 1st step: Initialisation
|
||||
// 1st step: initialization
|
||||
for(i=0;i<d;i++) {
|
||||
for(j=i;j<d;j++) {
|
||||
sum1 = ((j+sub)+1>m) ? NT(0) : -coeff(f,i+sub)*coeff(g,(j+sub)+1);
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ namespace internal {
|
|||
/*! \ingroup CGAL_determinant
|
||||
* \brief Will determine and execute a suitable determinant routine and
|
||||
* return the determinant of \a A.
|
||||
* (specialisation for CGAL::Matrix_d)
|
||||
* (specialization for CGAL::Matrix_d)
|
||||
*/
|
||||
template <class NT > inline
|
||||
NT determinant(const internal::Simple_matrix<NT>& A)
|
||||
|
|
@ -214,7 +214,7 @@ namespace internal {
|
|||
/*! \ingroup CGAL_determinant
|
||||
* \brief Computes the determinant of \a A according to the method proposed
|
||||
* by Berkowitz.
|
||||
* (specialisation for CGAL::Matrix_d)
|
||||
* (specialization for CGAL::Matrix_d)
|
||||
*
|
||||
* Note that this routine is completely free of divisions!
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ namespace CGAL {
|
|||
\ingroup PkgPolytopeDistanceDRef
|
||||
|
||||
The class `Polytope_distance_d_traits_2` is a traits class for the \f$ d\f$-dimensional
|
||||
optimisation algorithms using the two-dimensional \cgal kernel.
|
||||
optimization algorithms using the two-dimensional \cgal kernel.
|
||||
|
||||
|
||||
\tparam K must be a model for `Kernel`.
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ namespace CGAL {
|
|||
\ingroup PkgPolytopeDistanceDRef
|
||||
|
||||
The class `Polytope_distance_d_traits_3` is a traits class for the \f$ d\f$-dimensional
|
||||
optimisation algorithms using the three-dimensional \cgal kernel.
|
||||
optimization algorithms using the three-dimensional \cgal kernel.
|
||||
|
||||
|
||||
\tparam K must be a model for `Kernel`.
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue