mirror of https://github.com/CGAL/cgal
spelling corrections
Some spelling corrections (Directories starting with `A`)
This commit is contained in:
albert-github
parent
dd6b993e07
commit
014c06fd19
|
|
@ -334,7 +334,7 @@ void Scene::compute_elements(int mode)
|
|||
pos_points.push_back(p.z());
|
||||
}
|
||||
}
|
||||
//The Segements
|
||||
//The segments
|
||||
{
|
||||
std::list<Segment>::iterator sit;
|
||||
for(sit = m_segments.begin(); sit != m_segments.end(); sit++)
|
||||
|
|
|
|||
|
|
@ -390,7 +390,7 @@ query and location of query in space.
|
|||
number of primitive data (greater than 2M faces in our experiments)
|
||||
however we noticed that it is not necessary (and sometimes even
|
||||
slower) to use all reference points when constructing the
|
||||
KD-tree. In these cases we recommend to specify trough the function
|
||||
KD-tree. In these cases we recommend to specify through the function
|
||||
` AABB_tree::accelerate_distance_queries()` fewer reference
|
||||
points (typically not more than 100K) evenly distributed over the
|
||||
input primitives.
|
||||
|
|
|
|||
|
|
@ -213,7 +213,7 @@ public:
|
|||
/// Point query type.
|
||||
typedef typename GeomTraits::Point_3 Point_3;
|
||||
|
||||
/// additionnal types for the search tree, required by the RangeSearchTraits concept
|
||||
/// additional types for the search tree, required by the RangeSearchTraits concept
|
||||
/// \bug This is not documented for now in the AABBTraits concept.
|
||||
typedef typename GeomTraits::Iso_cuboid_3 Iso_cuboid_3;
|
||||
|
||||
|
|
@ -254,7 +254,7 @@ public:
|
|||
* @param beyond iterator on beyond element
|
||||
* @param bbox the bounding box of [first,beyond[
|
||||
*
|
||||
* Sorts the range defined by [first,beyond[. Sort is achieved on bbox longuest
|
||||
* Sorts the range defined by [first,beyond[. Sort is achieved on bbox longest
|
||||
* axis, using the comparison function `<dim>_less_than` (dim in {x,y,z})
|
||||
*/
|
||||
class Split_primitives
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ std::tuple<std::size_t, std::size_t, std::size_t, long> test(const char* name) {
|
|||
tu = std::make_tuple(intersect(lines.begin(), lines.end(), tree, counter),
|
||||
intersect(rays.begin(), rays.end(), tree, counter),
|
||||
intersect(segments.begin(), segments.end(), tree, counter),
|
||||
// cant use counter here
|
||||
// can't use counter here
|
||||
0);
|
||||
std::get<3>(tu) = counter;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
|
||||
#include <CGAL/tags.h>
|
||||
|
||||
// Makro to define an additional operator for binary functors which takes
|
||||
// Macro to define an additional operator for binary functors which takes
|
||||
// two number types as parameters that are interoperable with the
|
||||
// number type
|
||||
#define CGAL_IMPLICIT_INTEROPERABLE_BINARY_OPERATOR_WITH_RT( NT, Result_type ) \
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ class Parens_as_product_tag {};
|
|||
|
||||
/*! \ingroup NiX_io_parens
|
||||
* \brief decides whether this number requires parentheses
|
||||
* in case it appears within a produkt.
|
||||
* in case it appears within a product.
|
||||
*/
|
||||
template <class NT>
|
||||
struct Needs_parens_as_product{
|
||||
|
|
@ -37,7 +37,7 @@ struct Needs_parens_as_product{
|
|||
|
||||
/*! \ingroup NiX_io_parens
|
||||
* \brief decides whether this number requires parentheses
|
||||
* in case it appears within a produkt.
|
||||
* in case it appears within a product.
|
||||
*/
|
||||
template <class NT>
|
||||
inline bool needs_parens_as_product(const NT& x){
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ void test_rational_traits(){
|
|||
assert( Rational_traits().make_rational(std::make_pair(x,x)) == Rational(1));
|
||||
assert( Rational_traits().make_rational(std::make_pair(7,RT(2))) == x);
|
||||
|
||||
// gloabal function to_rational
|
||||
// global function to_rational
|
||||
x = CGAL::to_rational<Rational>(3.5);
|
||||
assert( x == Rational(7)/Rational(2));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ namespace CGAL {
|
|||
assert(to_interval(Type(42)).first > 41.99);
|
||||
assert(to_interval(Type(42)).second < 42.01);
|
||||
|
||||
// test neagtive numbers as well to catch obvious sign
|
||||
// test negative numbers as well to catch obvious sign
|
||||
// errors
|
||||
assert( -42.0 >= to_interval( -Type(42) ).first );
|
||||
assert( -42.0 <= to_interval( -Type(42) ).second );
|
||||
|
|
|
|||
|
|
@ -840,7 +840,7 @@ public:
|
|||
} else {
|
||||
// more work! We should not assume that each
|
||||
// roots[i].first has f or g as defining polynomial, because
|
||||
// the representation might have been simplifed
|
||||
// the representation might have been simplified
|
||||
|
||||
// Here's the safe way: Take the simpler of the curves
|
||||
// (but the one without vertical component!)
|
||||
|
|
@ -922,7 +922,7 @@ public:
|
|||
*
|
||||
* \attention{This method returns the y-coordinate in isolating interval
|
||||
* representation. Calculating such a representation is usually a time-
|
||||
* consuming taks, since it is against the "y-per-x"-view that we take
|
||||
* consuming task, since it is against the "y-per-x"-view that we take
|
||||
* in our kernel. Therefore, it is recommended, if possible,
|
||||
* to use the functors
|
||||
* \c Approximate_absolute_y_2 and \c Approximate_relative_y_2 that
|
||||
|
|
|
|||
|
|
@ -494,7 +494,7 @@ public:
|
|||
}
|
||||
}
|
||||
};
|
||||
} // namepace internal
|
||||
} // namespace internal
|
||||
|
||||
} //namespace CGAL
|
||||
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ namespace internal {
|
|||
// sign_at_low_ = polynomial_.evaluate(low_)
|
||||
// x is the only root of polynomial_ in the open interval ]low_,high_[
|
||||
// low_ != x != high
|
||||
// ******************* EXEPTION *******************
|
||||
// ******************* EXCEPTION *******************
|
||||
// x is rational: in this case low=high=x
|
||||
|
||||
template< class Coefficient_, class Rational_>
|
||||
|
|
@ -135,7 +135,7 @@ protected:
|
|||
|
||||
// interval_option left out
|
||||
|
||||
// trys to set rational if degree is 1
|
||||
// tries to set rational if degree is 1
|
||||
typedef typename CGAL::Coercion_traits< Coefficient, Rational >::Type RET;
|
||||
set_rational(RET());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ namespace internal {
|
|||
// sign_at_low_ = polynomial_.evaluate(low_)
|
||||
// x is the only root of polynomial_ in the open interval ]low_,high_[
|
||||
// low_ != x != high
|
||||
// ******************* EXEPTION *******************
|
||||
// ******************* EXCEPTION *******************
|
||||
// x is rational: in this case low=high=x
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1217,7 +1217,7 @@ public:
|
|||
*
|
||||
* The polynomial \c f must have exactly \c m real roots, counted without
|
||||
* multiplicity, and the degree of <tt>gcd(f,f')</tt> must be \c k. In this
|
||||
* case, the constructor either isolates the real roots of \c f sucessfully
|
||||
* case, the constructor either isolates the real roots of \c f successfully
|
||||
* or a Non_generic_position_exception is thrown. Such an exception
|
||||
* certainly occurs if \c f has more than one multiple real root. If \c f
|
||||
* has at most one multiple root over the complex numbers, the roots are
|
||||
|
|
|
|||
|
|
@ -443,7 +443,7 @@ private:
|
|||
Integer_vector coeff_; // wrt [lower_, upper_], approximate
|
||||
int min_var_, max_var_;
|
||||
bool coeff_update_delayed_;
|
||||
// "state data" (copied en bloc by .copy_state_from())
|
||||
// "state data" (copied en block by .copy_state_from())
|
||||
long subdepth_bound_, subdepth_current_;
|
||||
long log_eps_; // $q - p$
|
||||
long log_C_eps_; // $q - p + 4n$
|
||||
|
|
|
|||
|
|
@ -531,7 +531,7 @@ private:
|
|||
long log_bdry_den_;
|
||||
Integer_vector coeff_; // wrt [lower_, upper_], approximate
|
||||
int min_var_, max_var_;
|
||||
// "state data" (copied en bloc by .copy_state_from())
|
||||
// "state data" (copied en block by .copy_state_from())
|
||||
long subdiv_tries_, subdiv_fails_;
|
||||
long recdepth_;
|
||||
long log_sep_, delta_log_sep_, log_eps_, log_C_eps_;
|
||||
|
|
@ -736,7 +736,7 @@ public:
|
|||
<b>Supplying a traits class</b>
|
||||
|
||||
This class is actually a class template.
|
||||
To use it, you need to instanciate it with a traits class
|
||||
To use it, you need to instantiate it with a traits class
|
||||
that defines the following three types and the various
|
||||
functors on them listed below.
|
||||
- \c Coefficient: The type of coefficients supplied
|
||||
|
|
@ -749,7 +749,7 @@ public:
|
|||
- \c Bound: \c lower() and \c upper() return
|
||||
interval boundaries in this type. Must be \c Assignable.
|
||||
The canonical choice is \c NiX::Exact_float_number<Integer>.
|
||||
If you never instanciate \c lower() and \c upper()
|
||||
If you never instantiate \c lower() and \c upper()
|
||||
(maybe use \c boundaries() instead), you might be lucky
|
||||
and get away with typedef'ing this to \c void.
|
||||
|
||||
|
|
@ -772,7 +772,7 @@ public:
|
|||
- \c Lower_bound_log2_abs: A \c UnaryFunction with signature
|
||||
<tt>long l = Lower_bound_log2_abs()(Coefficient x)</tt>.
|
||||
The result \c l must be a lower bound to log<sub>2</sub>(|<i>x</i>|).
|
||||
If \c Coefficient posesses \c NiX::NT_traits::Floor_log2_abs,
|
||||
If \c Coefficient possesses \c NiX::NT_traits::Floor_log2_abs,
|
||||
you can simply use that.
|
||||
- \c lower_bound_log2_abs_object(): A \c const member function
|
||||
taking no arguments and returning a function object
|
||||
|
|
|
|||
|
|
@ -481,7 +481,7 @@ public:
|
|||
* \c internal::Zero_resultant_exception<Polynomial_2>,
|
||||
* instead of performing a shear.
|
||||
*
|
||||
* \Todo Currently the defualt strategy has been changed to SHEAR_STRATEGY
|
||||
* \Todo Currently the default strategy has been changed to SHEAR_STRATEGY
|
||||
* because there exist a problem if vertical asymtotes are present at
|
||||
* the rational x-coordinate.
|
||||
*/
|
||||
|
|
@ -1167,7 +1167,7 @@ public:
|
|||
|
||||
/*!
|
||||
* \brief returns the status line for the interval
|
||||
* preceeding the <tt>i</tt>th event
|
||||
* preceding the <tt>i</tt>th event
|
||||
*
|
||||
* Returns a status line for a reference x-coordinate of the <tt>i</tt>th
|
||||
* interval of the curve. If called multiple times for the same <tt>i</tt>,
|
||||
|
|
@ -1827,7 +1827,7 @@ private:
|
|||
static_cast<size_type>(lcoeff_roots.size()) &&
|
||||
event_values[i]==lcoeff_roots[curr_lcoeff_index]) {
|
||||
// We have a root of the leading coefficient
|
||||
// of the primitve polynomial
|
||||
// of the primitive polynomial
|
||||
curr_event.index_of_prim_lcoeff_root = curr_lcoeff_index;
|
||||
curr_event.mult_of_prim_lcoeff_root
|
||||
= lcoeff_mults[curr_lcoeff_index];
|
||||
|
|
@ -1867,7 +1867,7 @@ private:
|
|||
static_cast<size_type>(lcoeff_roots.size()) &&
|
||||
event_values[i]==lcoeff_roots[curr_lcoeff_index]) {
|
||||
// We have a root of the leading coefficient
|
||||
// of the primitve polynomial
|
||||
// of the primitive polynomial
|
||||
curr_event.index_of_prim_lcoeff_root = curr_lcoeff_index;
|
||||
curr_event.mult_of_prim_lcoeff_root
|
||||
= lcoeff_mults[curr_lcoeff_index];
|
||||
|
|
|
|||
|
|
@ -328,7 +328,7 @@ private:
|
|||
return false;
|
||||
return (P[0] != Coeff__(0) && P.evaluate(Coeff__(1)) != Coeff__(0));
|
||||
}
|
||||
//! Descartes algoritm to determine isolating intervals for the roots
|
||||
//! Descartes algorithm to determine isolating intervals for the roots
|
||||
//! lying in the interval (0,1).
|
||||
// The parameters $(i,D)$ describe the interval $(i/2^D, (i+1)/2^D)$.
|
||||
// Here $0\leq i < 2^D$.
|
||||
|
|
@ -389,7 +389,7 @@ private:
|
|||
}
|
||||
|
||||
|
||||
//! Strong Descartes algoritm to determine isolating intervals for the
|
||||
//! Strong Descartes algorithm to determine isolating intervals for the
|
||||
//! roots lying in the interval (0,1), where the first
|
||||
//! derivative have no sign change. \pre $P$ has only one root in the
|
||||
//! interval given by $(i,D)$.
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ public:
|
|||
* curve.
|
||||
*
|
||||
* Additionally, the \c id of the event line to be created has to be
|
||||
* specfied, and
|
||||
* specified, and
|
||||
* the number of arcs that are entering from the left and leaving to the
|
||||
* right are needed. Furthermore, the flag \c root_of_resultant tells
|
||||
* whether \c alpha is a root of the resultant of the specified curve, and
|
||||
|
|
@ -314,7 +314,7 @@ protected:
|
|||
*
|
||||
* If the first elements in the sequence are known to be zero,
|
||||
* \c first_elements_zero can be set accordingly. The zero test is then
|
||||
* ommitted for that leading elements.
|
||||
* omitted for that leading elements.
|
||||
*/
|
||||
template<typename InputIterator>
|
||||
std::pair<int,int> compute_mk(Algebraic_real_1 alpha,
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ namespace CGAL {
|
|||
|
||||
namespace internal {
|
||||
|
||||
// Don't define default, results in more convinient compiler messages
|
||||
// Don't define default, results in more convenient compiler messages
|
||||
template< class Type > class Float_traits;
|
||||
// {
|
||||
// public:
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ namespace internal {
|
|||
// TODO: Implement array in source code file
|
||||
// extern const signed char floor_log2_4bit[16]; // see src/floor_log2_4bit.C
|
||||
|
||||
// Don't define default, results in more convinient compiler messages
|
||||
// Don't define default, results in more convenient compiler messages
|
||||
template< class Type > class Real_embeddable_extension;
|
||||
// {
|
||||
// public:
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ public:
|
|||
}
|
||||
|
||||
/*!\brief
|
||||
* constructs from a given represenation
|
||||
* constructs from a given representation
|
||||
*/
|
||||
Status_line_CA_1(Rep rep) :
|
||||
Base(rep) {
|
||||
|
|
|
|||
|
|
@ -208,7 +208,7 @@ public:
|
|||
|
||||
protected:
|
||||
/*!\brief
|
||||
* constructs from a given represenation
|
||||
* constructs from a given representation
|
||||
*/
|
||||
Status_line_CPA_1(Rep rep) :
|
||||
Base(rep) {
|
||||
|
|
|
|||
|
|
@ -233,7 +233,7 @@ public:
|
|||
}
|
||||
|
||||
/*!\brief
|
||||
* constructs a point from a given represenation
|
||||
* constructs a point from a given representation
|
||||
*/
|
||||
Xy_coordinate_2(Rep rep) :
|
||||
Base(rep) {
|
||||
|
|
@ -254,7 +254,7 @@ public:
|
|||
/*!
|
||||
* \brief y-coordinate of this point
|
||||
*
|
||||
* Note: In general, this method results in a extremly large polynomial
|
||||
* Note: In general, this method results in a extremely large polynomial
|
||||
* for the y-coordinate. It is recommended to use it carefully,
|
||||
* and using get_approximation_y() instead whenever approximations suffice.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ template<typename AlgebraicKernel_1> typename AlgebraicKernel_1::Bound
|
|||
}
|
||||
|
||||
/*!
|
||||
* \brief finds a Rational value rightt of an Algebraic real alpha
|
||||
* \brief finds a Rational value right of an Algebraic real alpha
|
||||
*/
|
||||
template<typename AlgebraicKernel_1> typename AlgebraicKernel_1::Bound
|
||||
bound_right_of(const AlgebraicKernel_1* kernel,
|
||||
|
|
|
|||
|
|
@ -87,10 +87,10 @@
|
|||
* (i.e., vertical cusps, isolated points on arcs), and usual regular points.
|
||||
* The candidate point on each status line can be checked for being singular
|
||||
* using this flag. This gives additional information but increases
|
||||
* compuation time
|
||||
* computation time
|
||||
*
|
||||
* WARNING: Currently, the status line does not store the additional
|
||||
* information whether a point is singluar or not.
|
||||
* information whether a point is singular or not.
|
||||
* Therefore, there is currently no reasons to set this flag. It is still
|
||||
* contained for possible further extension of the status line.
|
||||
*/
|
||||
|
|
@ -171,7 +171,7 @@
|
|||
/**
|
||||
* The algorithm can also handle non-y-regular curves without shearing,
|
||||
* in case that the resultant multiplicity at vertical asymptotes is one.
|
||||
* This special treatement can be switched off by setting this flag.
|
||||
* This special treatment can be switched off by setting this flag.
|
||||
* It is not recommended to do this because of efficiency
|
||||
*/
|
||||
#ifndef CGAL_ACK_SHEAR_ALL_NOT_Y_REGULAR_CURVES
|
||||
|
|
|
|||
|
|
@ -111,7 +111,7 @@ public:
|
|||
|
||||
void operator()( Type& t, int rel_prec ) const {
|
||||
// If t is zero, we can refine the interval to
|
||||
// infinite precission
|
||||
// infinite precision
|
||||
if( CGAL::is_zero( t ) ) {
|
||||
t = Type(0);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ namespace RS_AK1{
|
|||
// Refiner_()(const Polynomial_&,Bound_&,Bound_&,int p);
|
||||
//
|
||||
// The fourth template argument is a comparator, a function object that
|
||||
// receives the polynomials and bounds defining two algebraic numbres and
|
||||
// receives the polynomials and bounds defining two algebraic numbers and
|
||||
// just compares them, returning a CGAL::Comparison_result. The signature
|
||||
// of a comparator must be:
|
||||
// CGAL::Comparison_result
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ namespace CGAL {
|
|||
typedef typename AK::Polynomial_1_3 Polynomial_1_3;
|
||||
// The degenerated cases are 2 tangent spheres
|
||||
// os 2 non-intersecting spheres
|
||||
// beacause we cannot have infinitely many solutions
|
||||
// because we cannot have infinitely many solutions
|
||||
if(e1 == e2) {
|
||||
if(tangent<AK>(e1,e3)) {
|
||||
Polynomial_1_3 p = plane_from_2_spheres<AK>(e1,e3);
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ how to convert from the camouflaged `CGAL::Point_3` to the two-dimensional point
|
|||
of `CGAL::Simple_cartesian<NT>`. In this case, a partial specialization of `Cartesian_converter`
|
||||
must be provided by the user. An example of such specialization is given in the example
|
||||
\ref Alpha_shapes_2/ex_alpha_projection_traits.cpp "ex_alpha_projection_traits.cpp".
|
||||
<li>The tag `ExactAlphaComparisonTag` cannot be used in conjonction with periodic triangulations.
|
||||
<li>The tag `ExactAlphaComparisonTag` cannot be used in conjunction with periodic triangulations.
|
||||
When the tag `ExactAlphaComparisonTag` is set to \link Tag_true `Tag_true`\endlink,
|
||||
the evaluations of predicates such as `Side_of_oriented_circle_2` are done lazily.
|
||||
Consequently, the predicates store pointers to the geometrical positions of the
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ public:
|
|||
typedef typename Dt::Geom_traits Gt;
|
||||
typedef typename Dt::Triangulation_data_structure Tds;
|
||||
|
||||
// The Exact Comparison Tag cannot be used in conjonction with periodic triangulations
|
||||
// The Exact Comparison Tag cannot be used in conjunction with periodic triangulations
|
||||
// because the periodic triangulations' point() function returns a temporary
|
||||
// value while the lazy predicate evaluations that are used when the Exact tag
|
||||
// is set to true rely on a permanent and safe access to the points.
|
||||
|
|
@ -432,7 +432,7 @@ public:
|
|||
private:
|
||||
|
||||
// the dynamic version is not yet implemented
|
||||
// desactivate the triangulation member functions
|
||||
// deactivate the triangulation member functions
|
||||
Vertex_handle insert(const Point& p);
|
||||
// Inserts point `p' in the alpha shape and returns the
|
||||
// corresponding vertex of the underlying Delaunay triangulation.
|
||||
|
|
@ -744,7 +744,7 @@ private:
|
|||
//---------------------------------------------------------------------
|
||||
|
||||
private:
|
||||
// prevent default copy constructor and default assigment
|
||||
// prevent default copy constructor and default assignment
|
||||
|
||||
Alpha_shape_2(const Alpha_shape_2& A);
|
||||
|
||||
|
|
@ -1435,7 +1435,7 @@ template < class Dt, class EACT >
|
|||
typename Alpha_shape_2<Dt,EACT>::Type_of_alpha
|
||||
Alpha_shape_2<Dt,EACT>::find_alpha_solid() const
|
||||
{
|
||||
// compute the minumum alpha such that all data points
|
||||
// compute the minimum alpha such that all data points
|
||||
// are either on the boundary or in the interior
|
||||
// not necessarily connected
|
||||
// starting point for searching
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ class Lazy_alpha_nt_2
|
|||
typedef typename Types::Exact_point Exact_point;
|
||||
typedef typename Types::Input_point Input_point;
|
||||
|
||||
//Convertion functions
|
||||
//Conversion functions
|
||||
Approx_point to_approx(const Input_point& wp) const
|
||||
{
|
||||
// The traits class' Point_2 must be convertible using the Cartesian converter
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
- deprectate the following function
|
||||
- deprecate the following function
|
||||
Classification_type A.classify ( Cell_handle f, int i, FT alpha = get_alpha())
|
||||
because it is ambiguous with
|
||||
Classification_type A.classify ( Cell_handle f, FT alpha = get_alpha())
|
||||
|
|
@ -12,7 +12,7 @@ when alpha is given as an int.
|
|||
Alpha_shape_3(Dt& dt, bool swap=true, NT alpha = 0, Mode m = REGULARIZED)
|
||||
The triangulation is swapped if swap=true and copied otherwise.
|
||||
|
||||
- test the taking into account of paramater alpha in functions
|
||||
- test the taking into account of parameter alpha in functions
|
||||
get_alpha_shape_edges
|
||||
get_alpha_shape_facets
|
||||
get_alpha_shape_vertices
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
|||
# include(${QT_USE_FILE})
|
||||
include_directories(BEFORE ./)
|
||||
|
||||
# ui file, created wih Qt Designer
|
||||
# ui file, created with Qt Designer
|
||||
qt5_wrap_ui(uis MainWindow.ui)
|
||||
|
||||
# qrc files (resources files, that contain icons, at least)
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ the basic `Cartesian_converter`, for example when a custom point is used.
|
|||
In this case, a partial specialization of `Cartesian_converter`
|
||||
must be provided by the user. An example of such specialization is given in the
|
||||
two-dimensional Alpha Shapes example \ref Alpha_shapes_2/ex_alpha_projection_traits.cpp "ex_alpha_projection_traits.cpp".
|
||||
<li>The tag `ExactAlphaComparisonTag` cannot be used in conjonction with periodic triangulations.
|
||||
<li>The tag `ExactAlphaComparisonTag` cannot be used in conjunction with periodic triangulations.
|
||||
When the tag `ExactAlphaComparisonTag` is set to \link Tag_true `Tag_true`\endlink,
|
||||
the evaluations of predicates such as `Side_of_oriented_sphere_3` are done lazily.
|
||||
Consequently, the predicates store pointers to the geometrical positions of the
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ int main()
|
|||
|
||||
// compute alpha shape
|
||||
Alpha_shape_3 as(dt);
|
||||
std::cout << "Alpha shape computed in REGULARIZED mode by defaut."
|
||||
std::cout << "Alpha shape computed in REGULARIZED mode by default."
|
||||
<< std::endl;
|
||||
|
||||
// find optimal alpha values
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ class Alpha_shape_3 : public Dt
|
|||
// or INTERIOR with respect to the alpha shape.
|
||||
// In GENERAL mode a $k$ simplex is REGULAR if it is on the boundary
|
||||
// of the alpha_complex and belongs to a $k+1$ simplex in the complex
|
||||
// and it is SINGULAR simplex if it is a boundary simplex tht is not
|
||||
// and it is SINGULAR simplex if it is a boundary simplex that is not
|
||||
// included in a $k+1$ simplex of the complex.
|
||||
|
||||
// In REGULARIZED mode each k-dimensional simplex of the triangulation
|
||||
|
|
@ -93,7 +93,7 @@ public:
|
|||
typedef typename Dt::Geom_traits Gt;
|
||||
typedef typename Dt::Triangulation_data_structure Tds;
|
||||
|
||||
// The Exact Comparison Tag cannot be used in conjonction with periodic triangulations
|
||||
// The Exact Comparison Tag cannot be used in conjunction with periodic triangulations
|
||||
// because the periodic triangulations' point() function returns a temporary
|
||||
// value while the lazy predicate evaluations that are used when the Exact tag
|
||||
// is set to true rely on a permanent and safe access to the points.
|
||||
|
|
@ -422,7 +422,7 @@ public:
|
|||
private:
|
||||
|
||||
// the dynamic version is not yet implemented
|
||||
// desactivate the tetrahedralization member functions
|
||||
// deactivate the tetrahedralization member functions
|
||||
void insert(const Point& /*p*/) {}
|
||||
// Inserts point `p' in the alpha shape and returns the
|
||||
// corresponding vertex of the underlying Delaunay tetrahedralization.
|
||||
|
|
@ -735,7 +735,7 @@ public:
|
|||
// (2) the nb of solid components is equal or less than nb_component
|
||||
|
||||
NT find_alpha_solid() const;
|
||||
// compute the minumum alpha such that all data points
|
||||
// compute the minimum alpha such that all data points
|
||||
// are either on the boundary or in the interior
|
||||
// not necessarily connected
|
||||
// starting point for searching
|
||||
|
|
@ -776,7 +776,7 @@ private:
|
|||
//---------------------------------------------------------------------
|
||||
|
||||
private:
|
||||
// prevent default copy constructor and default assigment
|
||||
// prevent default copy constructor and default assignment
|
||||
Alpha_shape_3(const Alpha_shape_3&);
|
||||
void operator=(const Alpha_shape_3&);
|
||||
|
||||
|
|
@ -1292,7 +1292,7 @@ Alpha_shape_3<Dt,EACT>::initialize_alpha_vertex_maps(bool reinitialize)
|
|||
back_inserter(incidents));
|
||||
typename std::list<Cell_handle>::iterator chit=incidents.begin();
|
||||
if (is_infinite(*chit)) as->set_is_on_chull(true);
|
||||
while (is_infinite(*chit)) ++chit; //skip infinte cells
|
||||
while (is_infinite(*chit)) ++chit; //skip infinite cells
|
||||
alpha = (*chit)->get_alpha();
|
||||
as->set_alpha_mid(alpha);
|
||||
as->set_alpha_max(alpha);
|
||||
|
|
@ -1330,7 +1330,7 @@ Alpha_shape_3<Dt,EACT>::initialize_alpha_vertex_maps(bool reinitialize)
|
|||
incident_cells(static_cast<Vertex_handle>(vit),
|
||||
back_inserter(incidents));
|
||||
typename std::list<Cell_handle>::iterator chit=incidents.begin();
|
||||
while (is_infinite(*chit)) ++chit; //skip infinte cells
|
||||
while (is_infinite(*chit)) ++chit; //skip infinite cells
|
||||
alpha = (*chit)->get_alpha();
|
||||
as->set_alpha_mid(alpha);
|
||||
for( ; chit != incidents.end(); ++chit) {
|
||||
|
|
@ -1835,7 +1835,7 @@ Alpha_shape_3<Dt,EACT>::find_optimal_alpha(size_type nb_components) const
|
|||
template <class Dt,class EACT>
|
||||
typename Alpha_shape_3<Dt,EACT>::NT
|
||||
Alpha_shape_3<Dt,EACT>::find_alpha_solid() const
|
||||
// compute the minumum alpha such that all data points
|
||||
// compute the minimum alpha such that all data points
|
||||
// are either on the boundary or in the interior
|
||||
// not necessarily connected
|
||||
{
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ class Lazy_alpha_nt_3{
|
|||
typedef typename Types::Approx_point Approx_point;
|
||||
typedef typename Types::Exact_point Exact_point;
|
||||
typedef typename Types::Input_point Input_point;
|
||||
//Convertion functions
|
||||
//Conversion functions
|
||||
Approx_point to_approx(const Input_point& wp) const
|
||||
{
|
||||
// The traits class' Point_3 must be convertible using the Cartesian converter
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ class Fixed_alpha_shape_3 : public Dt
|
|||
// or INTERIOR with respect to the alpha shape.
|
||||
// A $k$ simplex is REGULAR if it is on the boundary
|
||||
// of the alpha_complex and belongs to a $k+1$ simplex in the complex
|
||||
// and it is SINGULAR simplex if it is a boundary simplex tht is not
|
||||
// and it is SINGULAR simplex if it is a boundary simplex that is not
|
||||
// included in a $k+1$ simplex of the complex.
|
||||
|
||||
// Roughly, the Fixed_alpha_shape data structure computes and stores,
|
||||
|
|
@ -280,7 +280,7 @@ public:
|
|||
}
|
||||
}
|
||||
// Erase from edge_status_map, edges that will disappear:
|
||||
// they are not on the boudary of the hole
|
||||
// they are not on the boundary of the hole
|
||||
std::set<Edge,Compare_edge> hole_edges;
|
||||
std::pair<typename std::set<Edge,Compare_edge>::iterator,bool> it_hedge_and_not_already_seen;
|
||||
for (typename std::vector<Cell_handle>::iterator it=cells.begin();it!=cells.end();++it){
|
||||
|
|
@ -598,7 +598,7 @@ private :
|
|||
}
|
||||
|
||||
private :
|
||||
// prevent default copy constructor and default assigment
|
||||
// prevent default copy constructor and default assignment
|
||||
Fixed_alpha_shape_3(const Fixed_alpha_shape_3&);
|
||||
void operator=(const Fixed_alpha_shape_3&);
|
||||
|
||||
|
|
|
|||
|
|
@ -152,7 +152,7 @@ _test_cls_alpha_shape_3()
|
|||
test_filtration(a1,verbose);
|
||||
|
||||
std::cout << std::endl;
|
||||
std::cout << "test additionnal creators and set mode" << std::endl;
|
||||
std::cout << "test additional creators and set mode" << std::endl;
|
||||
Triangulation dt2( L.begin(), L.end());
|
||||
Alpha_shape_3 a2(dt2, 0, Alpha_shape_3::REGULARIZED);
|
||||
if(verbose) show_alpha_values(a2);
|
||||
|
|
@ -193,10 +193,10 @@ _test_cls_alpha_shape_3()
|
|||
Alpha_iterator previous = opt; --previous;
|
||||
if(verbose) {
|
||||
std::cerr << " optimal de 1 " << *opt
|
||||
<< "nb of componants " << a1.number_of_solid_components(*opt)
|
||||
<< "nb of components " << a1.number_of_solid_components(*opt)
|
||||
<< std::endl;
|
||||
std::cerr << " previous " << *previous
|
||||
<< "nb of componants "
|
||||
<< "nb of components "
|
||||
<< a1.number_of_solid_components(*previous) << std::endl;
|
||||
}
|
||||
assert (a1.number_of_solid_components(*opt) == 1);
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ and values of alpha smaller than the size of the holes.
|
|||
Two-sided wrap.
|
||||
(Left) Wrapping a Bunny in 2D, with decreasing values for alpha.
|
||||
(Right) Wrapping a defect-laden Bunny in 3D. The rightmost column depicts a clipped visualization
|
||||
of the inside. When alpha is small enough with respect the diamater of the holes, the algorithm generates a two-sided wrap.
|
||||
of the inside. When alpha is small enough with respect the diameter of the holes, the algorithm generates a two-sided wrap.
|
||||
\cgalFigureCaptionEnd
|
||||
|
||||
\section aw3_performance Performance
|
||||
|
|
|
|||
|
|
@ -192,7 +192,7 @@ public:
|
|||
m_queue(4096)
|
||||
{
|
||||
// Due to the Steiner point computation being a dichotomy, the algorithm is inherently inexact
|
||||
// and passing exact kernels is explicitely disabled to ensure no misunderstanding.
|
||||
// and passing exact kernels is explicitly disabled to ensure no misunderstanding.
|
||||
CGAL_static_assertion((std::is_floating_point<FT>::value));
|
||||
}
|
||||
|
||||
|
|
@ -944,7 +944,7 @@ private:
|
|||
return IRRELEVANT;
|
||||
}
|
||||
|
||||
// push if facet is connected to artifical vertices
|
||||
// push if facet is connected to artificial vertices
|
||||
for(int i=0; i<3; ++i)
|
||||
{
|
||||
const Vertex_handle vh = ch->vertex(Dt::vertex_triple_index(id, i));
|
||||
|
|
@ -1049,7 +1049,7 @@ private:
|
|||
check_queue_sanity();
|
||||
#endif
|
||||
|
||||
// const& to something that will be poped, but safe as `ch` && `id` are extracted before the pop
|
||||
// const& to something that will be popped, but safe as `ch` && `id` are extracted before the pop
|
||||
const Gate& gate = m_queue.top();
|
||||
const Facet& f = gate.facet();
|
||||
CGAL_precondition(!m_dt.is_infinite(f));
|
||||
|
|
|
|||
|
|
@ -167,7 +167,7 @@ struct AABB_tree_splitter_traits
|
|||
// The input face ID serves when traversing the tree, to avoid doing the same intersection()
|
||||
// on the same datum seen from different primitives.
|
||||
//
|
||||
// Technically, FPM could type-erase the mesh and the VPM, as it currently forces all independant
|
||||
// Technically, FPM could type-erase the mesh and the VPM, as it currently forces all independent
|
||||
// inputs to have the same types. This is not such much of an issue for the mesh type,
|
||||
// but it can be annoying for the VPM type.
|
||||
using ID = std::pair<std::size_t /*primitive ID*/, std::size_t /*input face ID*/>;
|
||||
|
|
|
|||
|
|
@ -1960,7 +1960,7 @@ template<class Gt, class Agds, class LTag>
|
|||
void
|
||||
Apollonius_graph_2<Gt,Agds,LTag>::file_output(std::ostream& os) const
|
||||
{
|
||||
// ouput to a file
|
||||
// output to a file
|
||||
size_type n = this->_tds.number_of_vertices();
|
||||
size_type m = this->_tds.number_of_full_dim_faces();
|
||||
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ Apollonius_graph_hierarchy_2
|
|||
}
|
||||
|
||||
|
||||
//Assignement
|
||||
//Assignment
|
||||
template<class Gt, class Agds, class LTag>
|
||||
Apollonius_graph_hierarchy_2<Gt,Agds,LTag> &
|
||||
Apollonius_graph_hierarchy_2<Gt,Agds,LTag>::
|
||||
|
|
|
|||
|
|
@ -268,7 +268,7 @@ private:
|
|||
{
|
||||
// NOTE:***************************************
|
||||
// * the perturb boolean variable is not used
|
||||
// * for consistancy with Menelaos
|
||||
// * for consistency with Menelaos
|
||||
// NOTE:***************************************
|
||||
RT x2 = p2.x() - p1.x();
|
||||
RT y2 = p2.y() - p1.y();
|
||||
|
|
@ -298,10 +298,10 @@ private:
|
|||
if ( is_indeterminate(s_xw2q) ) { return s_xw2q; }
|
||||
power_test = o12 * s_xw2q;
|
||||
|
||||
// this results is consistant with Menelaos
|
||||
// this results is consistent with Menelaos
|
||||
if (power_test != ZERO) { return -power_test; }
|
||||
|
||||
// this result is consistant with the perturb on off idea
|
||||
// this result is consistent with the perturb on off idea
|
||||
//if (power_test != ZERO || ! perturb) return -power_test;
|
||||
|
||||
o1q = CGAL::sign(xq);
|
||||
|
|
@ -313,10 +313,10 @@ private:
|
|||
if ( is_indeterminate(s_yw2q) ) { return s_yw2q; }
|
||||
power_test = o12 * s_yw2q;
|
||||
|
||||
// this results is consistant with Menelaos
|
||||
// this results is consistent with Menelaos
|
||||
if (power_test != ZERO) { return -power_test; }
|
||||
|
||||
// this result is consistant with the perturb on off idea
|
||||
// this result is consistent with the perturb on off idea
|
||||
//if (power_test != ZERO || ! perturb) return -power_test;
|
||||
|
||||
o1q = CGAL::sign(yq);
|
||||
|
|
@ -348,11 +348,11 @@ private:
|
|||
- CGAL::square(xy2q));
|
||||
if ( is_indeterminate(radInt) ) { return radInt; }
|
||||
|
||||
// radical intersection degerate
|
||||
// radical intersection degenerate
|
||||
if (radInt == ZERO) {
|
||||
CGAL_assertion (radSide != ZERO);
|
||||
|
||||
// this result is consistant with the perturb on off idea
|
||||
// this result is consistent with the perturb on off idea
|
||||
//if (! perturb) return (radSide == orient) ? ZERO : orient;
|
||||
|
||||
RT rs2q1 = (p2.x() - q.x()) * xw2q + (p2.y() - q.y()) * yw2q;
|
||||
|
|
|
|||
|
|
@ -879,7 +879,7 @@ bool test_algo(InputStream& is)
|
|||
// Patch for the Microsoft compiler so that it does not produce the
|
||||
// nasty warning about decorated name length
|
||||
// Basically what I do here is create typedefs for the default
|
||||
// template paramaters so as to give them shorter names
|
||||
// template parameters so as to give them shorter names
|
||||
typedef Apollonius_graph_vertex_base_2<Traits,true> Vb;
|
||||
typedef Triangulation_face_base_2<Traits> Fb;
|
||||
typedef Triangulation_data_structure_2<Vb,Fb> Agds;
|
||||
|
|
@ -904,7 +904,7 @@ bool test_hierarchy_algo(InputStream& is)
|
|||
// Patch for the Microsoft compiler so that it does not produce the
|
||||
// nasty warning about decorated name length
|
||||
// Basically what I do here is create typedefs for the default
|
||||
// template paramaters so as to give them shorter names
|
||||
// template parameters so as to give them shorter names
|
||||
typedef Apollonius_graph_vertex_base_2<Traits,true> Vb;
|
||||
typedef Apollonius_graph_hierarchy_vertex_base_2<Vb> HVb;
|
||||
typedef Triangulation_face_base_2<Traits> Fb;
|
||||
|
|
@ -934,7 +934,7 @@ bool test_filtered_traits_algo(InputStream& is)
|
|||
// Patch for the Microsoft compiler so that it does not produce the
|
||||
// nasty warning about decorated name length
|
||||
// Basically what I do here is create typedefs for the default
|
||||
// template paramaters so as to give them shorter names
|
||||
// template parameters so as to give them shorter names
|
||||
typedef Apollonius_graph_vertex_base_2<Traits,true> Vb;
|
||||
typedef Triangulation_face_base_2<Traits> Fb;
|
||||
typedef Triangulation_data_structure_2<Vb,Fb> Agds;
|
||||
|
|
@ -961,7 +961,7 @@ bool test_filtered_traits_hierarchy_algo(InputStream& is)
|
|||
// Patch for the Microsoft compiler so that it does not produce the
|
||||
// nasty warning about decorated name length
|
||||
// Basically what I do here is create typedefs for the default
|
||||
// template paramaters so as to give them shorter names
|
||||
// template parameters so as to give them shorter names
|
||||
typedef Apollonius_graph_vertex_base_2<Traits,true> Vb;
|
||||
typedef Apollonius_graph_hierarchy_vertex_base_2<Vb> HVb;
|
||||
typedef Triangulation_face_base_2<Traits> Fb;
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ class CORE_arithmetic_kernel : public internal::Arithmetic_kernel_base {
|
|||
public:
|
||||
//! exact integers
|
||||
typedef CORE::BigInt Integer;
|
||||
//! exact float nummber
|
||||
//! exact float number
|
||||
typedef CORE::BigRat Exact_float_number;
|
||||
//! exact rationals, constructible from integers
|
||||
typedef CORE::BigRat Rational;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
An Arithmetic_kernel is required to provide at least the following public types:
|
||||
Integer, Rational, Bigfloat_interval. It is guranteed that these types are interoperable. Currently there are:
|
||||
Integer, Rational, Bigfloat_interval. It is guaranteed that these types are interoperable. Currently there are:
|
||||
Gmp_arithmetic_kernel
|
||||
CORE_arithmetic_kernel
|
||||
LEDA_arithmetic_kernel
|
||||
|
||||
Moreover, the package provides a class template Get_arithmetic_kernel<T>. This cclass provides the corresponding Arithmetic_kernel for T. Note that T may also be a non trivial type such as Sqrt_extension, Polynomial etc.
|
||||
Moreover, the package provides a class template Get_arithmetic_kernel<T>. This class provides the corresponding Arithmetic_kernel for T. Note that T may also be a non trivial type such as Sqrt_extension, Polynomial etc.
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ public:
|
|||
/*! Is a conivs arc currently being processed? */
|
||||
bool m_processing_arc;
|
||||
|
||||
/*! A place holder to store the undelying conic of a conic arc */
|
||||
/*! A place holder to store the underlying conic of a conic arc */
|
||||
Curve_2 m_conic;
|
||||
|
||||
/*! Last orientation */
|
||||
|
|
@ -263,7 +263,7 @@ public:
|
|||
/*! Read the conic curves or arcs of conic curves from the input file
|
||||
* \param filename the name of the input file
|
||||
* \param curves_out the iterator of the container of the read curves
|
||||
* \param bbox the counding box of the read curves
|
||||
* \param bbox the bounding box of the read curves
|
||||
*/
|
||||
template<class OutputIterator>
|
||||
int read_data(const char * filename, OutputIterator curves_out,
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ public:
|
|||
return(*this);
|
||||
}
|
||||
|
||||
// Arithmetic opertors.
|
||||
// Arithmetic operators.
|
||||
Double operator+(const Double & x) const { return Double(val + x.val); }
|
||||
|
||||
Double operator-(const Double & x) const { return Double(val - x.val); }
|
||||
|
|
@ -48,7 +48,7 @@ public:
|
|||
// Unary minus.
|
||||
Double operator-() const { return Double(-val); }
|
||||
|
||||
// Arithmetic opertors and assignment.
|
||||
// Arithmetic operators and assignment.
|
||||
void operator+=(const Double & x) { val += x.val; }
|
||||
|
||||
void operator-=(const Double & x) { val -= x.val; }
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ public:
|
|||
std::cout << "Duplicate point: " << point << std::endl;
|
||||
}
|
||||
|
||||
/*! Parse a generic Homogenuous point */
|
||||
/*! Parse a generic Homogeneous point */
|
||||
virtual void accept_point_2( std::string x, std::string y, std::string w)
|
||||
{
|
||||
typedef typename Number_type_traits<Rat_number_type>::FT FT;
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ public:
|
|||
/*! Read the segments from the input file
|
||||
* \param filename the name of the input file
|
||||
* \param curves_out the iterator of the container of the read curves
|
||||
* \param bbox the counding box of the read curves
|
||||
* \param bbox the bounding box of the read curves
|
||||
*/
|
||||
template<class OutputIterator>
|
||||
int read_data(const char * filename, OutputIterator curves_out,
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ public:
|
|||
typedef typename Traits::Point_2 Point_2;
|
||||
typedef typename Traits::Curve_2 Curve_2;
|
||||
|
||||
/*! A visitor of the parser that reads segements */
|
||||
/*! A visitor of the parser that reads segments */
|
||||
template <class OutputIterator>
|
||||
class Segment_parser_visitor :
|
||||
public Point_parser_visitor<Kernel, Point_2, Number_type> {
|
||||
|
|
@ -71,7 +71,7 @@ public:
|
|||
/*! Read the segments from the input file
|
||||
* \param filename the name of the input file
|
||||
* \param curves_out the iterator of the container of the read curves
|
||||
* \param bbox the counding box of the read curves
|
||||
* \param bbox the bounding box of the read curves
|
||||
*/
|
||||
template<class OutputIterator>
|
||||
int read_data(const char * filename, OutputIterator curves_out,
|
||||
|
|
|
|||
|
|
@ -590,7 +590,7 @@ void run_bench(Bench_inst & bench_inst, Benchable & benchable,
|
|||
if (samples > 0) bench_inst.set_samples(samples);
|
||||
else if (iterations > 0) bench_inst.set_iterations(iterations);
|
||||
|
||||
//opertor () in the Bench - does all the work !
|
||||
//operator () in the Bench - does all the work !
|
||||
bench_inst();
|
||||
}
|
||||
|
||||
|
|
@ -648,7 +648,7 @@ int main(int argc, char * argv[])
|
|||
std::cout << "strategy_mask = " << strategy_mask << std::endl;
|
||||
}
|
||||
|
||||
// Construct Incrementaly (only if type_code == incremental)
|
||||
// Construct Incrementally (only if type_code == incremental)
|
||||
type_code = Option_parser::TYPE_INCREMENT;
|
||||
if (type_mask & (0x1 << type_code)) {
|
||||
if (verbose_level > 0) std::cout << "TYPE_INCREMENT " << std::endl;
|
||||
|
|
|
|||
|
|
@ -191,7 +191,7 @@ void ArrangementGraphicsItem<Arr_>::paintWithFloodFill(
|
|||
|
||||
// paint bounded faces normally?
|
||||
// by experimenting it's faster to just paint all using the flood algo
|
||||
// specially with algebraic faces since currenlty all edges have to
|
||||
// specially with algebraic faces since currently all edges have to
|
||||
// be recalculated/rendered again for faces
|
||||
// this->paintFaces(&painter2);
|
||||
this->paintEdges(&painter2, traits);
|
||||
|
|
@ -588,7 +588,7 @@ void ArrangementGraphicsItem<Arr_>::paintFace(
|
|||
|
||||
Halfedge_handle he = cc;
|
||||
X_monotone_curve_2 c = he->curve();
|
||||
// Get the co-ordinates of the curve's source and target.
|
||||
// Get the coordinates of the curve's source and target.
|
||||
double sx = CGAL::to_double(he->source()->point().x()),
|
||||
sy = CGAL::to_double(he->source()->point().y()),
|
||||
tx = CGAL::to_double(he->target()->point().x()),
|
||||
|
|
@ -606,7 +606,7 @@ void ArrangementGraphicsItem<Arr_>::paintFace(
|
|||
else
|
||||
{
|
||||
// If the curve is monotone, than its source and its target has the
|
||||
// extreme x co-ordinates on this curve.
|
||||
// extreme x coordinates on this curve.
|
||||
bool is_source_left = (sx < tx);
|
||||
int x_min = is_source_left ? coord_source_viewport.x()
|
||||
: coord_target_viewport.x();
|
||||
|
|
|
|||
|
|
@ -186,7 +186,7 @@ ArrangementPainterOstream<CGAL::Arr_conic_traits_2<
|
|||
QGraphicsView* view = this->scene->views().first();
|
||||
int xmin = view->mapFromScene(bb.xmin(), bb.ymin()).x();
|
||||
int xmax = view->mapFromScene(bb.xmax(), bb.ymin()).x();
|
||||
// can be negitive due to rotation trasnformation
|
||||
// can be negative due to rotation transformation
|
||||
size_t n = static_cast<size_t>(std::abs(xmax - xmin));
|
||||
if (n == 0) { return *this; }
|
||||
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ class FloodFill
|
|||
public:
|
||||
// this currently assumes that there is a "border" in the boundaries that
|
||||
// will prevent the flood fill from going there
|
||||
// this way we don't check bounadry conditions!
|
||||
// this way we don't check boundary conditions!
|
||||
void
|
||||
operator()(QRgb* raw_img, uint16_t width, uint16_t x, uint16_t y, QRgb color);
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ class QGraphicsView;
|
|||
class GraphicsSceneMixin
|
||||
{
|
||||
public:
|
||||
/*! Costructor */
|
||||
/*! Constructor */
|
||||
GraphicsSceneMixin(QGraphicsScene* scene_ = nullptr);
|
||||
|
||||
/*! Destructor (virtual) */
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ double Compute_squared_distance_2<
|
|||
CGAL::Arr_conic_traits_2<RatKernel, AlgKernel, NtTraits>>::
|
||||
operator()(const Point_2& p, const X_monotone_curve_2& c) const
|
||||
{
|
||||
// Get the co-ordinates of the curve's source and target.
|
||||
// Get the coordinates of the curve's source and target.
|
||||
// double sx = CGAL::to_double( c.source( ).x( ) );
|
||||
// double sy = CGAL::to_double( c.source( ).y( ) );
|
||||
// double tx = CGAL::to_double( c.target( ).x( ) );
|
||||
|
|
@ -111,7 +111,7 @@ operator()(const Point_2& p, const X_monotone_curve_2& c) const
|
|||
else
|
||||
{
|
||||
// If the curve is monotone, than its source and its target has the
|
||||
// extreme x co-ordinates on this curve.
|
||||
// extreme x coordinates on this curve.
|
||||
// bool is_source_left = (sx < tx);
|
||||
// int x_min = is_source_left ? (*w).x_pixel(sx) : (*w).x_pixel(tx);
|
||||
// int x_max = is_source_left ? (*w).x_pixel(tx) : (*w).x_pixel(sx);
|
||||
|
|
|
|||
|
|
@ -281,7 +281,7 @@ public:
|
|||
double operator()(const Point_2& p, const X_monotone_curve_2& c) const;
|
||||
};
|
||||
|
||||
// chcek if arrangement is a model of the concept ArrangementOpenBoundaryTraits_2
|
||||
// check if arrangement is a model of the concept ArrangementOpenBoundaryTraits_2
|
||||
template <typename ArrTraits>
|
||||
struct IsOpenBoundaryArrangement :
|
||||
public CGAL::Boolean_tag<
|
||||
|
|
|
|||
|
|
@ -376,7 +376,7 @@ public:
|
|||
*/
|
||||
Point_2(const typename Alg_kernel::Point_2& p);
|
||||
|
||||
/*! constructs from homegeneous coordinates.
|
||||
/*! constructs from homogeneous coordinates.
|
||||
*/
|
||||
Point_2(const Algebraic& hx, const Algebraic& hy, const Algebraic& hz);
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ namespace CGAL {
|
|||
* We use the following parameterization of the unit sphere \f$S =
|
||||
* \phi_S(\Phi)\f$: \f$\Phi = [\alpha, 2\pi + \alpha] \times [-\frac{\pi}{2},
|
||||
* \frac{\pi}{2}]\f$, \f$\phi_S(x, y) = (\cos y \cos x, \sin y \cos x, \sin
|
||||
* x)\f$, where \f$\alpha = \arctan(X, Y)\f$. By deafult, \f$X = -1, Y = 0\f$,
|
||||
* x)\f$, where \f$\alpha = \arctan(X, Y)\f$. By default, \f$X = -1, Y = 0\f$,
|
||||
* which implies \f$\alpha = \pi\f$, and a default parameterization \f$\Phi =
|
||||
* [-\pi, \pi] \times [-\frac{\pi}{2}, \frac{\pi}{2}]\f$. The equator curve,
|
||||
* for example, is given by \f$\gamma(t) = (\pi(2t - 1) + \alpha, 0)\f$, for
|
||||
|
|
@ -365,7 +365,7 @@ namespace CGAL {
|
|||
X_monotone_curve_2 operator()(const Point_2& p, const Point_2& q);
|
||||
|
||||
/*! Construct a full great circle from a normal to a plane.
|
||||
* Observe that the constrcted arc has one endpoint that lies on
|
||||
* Observe that the constructed arc has one endpoint that lies on
|
||||
* the identification curve. This point is considered both the source and
|
||||
* target (and also the left and right) point of the arc.
|
||||
* \param normal the normal to the plane containing the great circle.
|
||||
|
|
|
|||
|
|
@ -72,4 +72,4 @@ void overlay (const Arrangement_with_history_2<Traits,Dcel1>& arr1,
|
|||
|
||||
|
||||
|
||||
} /* end namesapce CGAL */
|
||||
} /* end namespace CGAL */
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ namespace CGAL {
|
|||
* or line segments. We call such a compound curve a polycurve. A polycurve
|
||||
* is a chain of subcurves, where each two neighboring subcurves in the chain
|
||||
* share a common endpoint; that is, the polycurve is continuous. Furthermore,
|
||||
* the target of the \f$i\f$th segement of a polycurve has to coincide with
|
||||
* the target of the \f$i\f$th segment of a polycurve has to coincide with
|
||||
* the source of the \f$i+1\f$st segment; that is, the polycurve has to be
|
||||
* \a well-oriented. Note that it is possible to construct general polycurves
|
||||
* that are neither continuous nor well-oriented, as it is impossible to
|
||||
|
|
@ -231,7 +231,7 @@ namespace CGAL {
|
|||
public:
|
||||
/*! Obtain a trimmed version of the polycurve with src and tgt as end
|
||||
* vertices.
|
||||
* Src and tgt will be swaped if they do not conform to the direction of
|
||||
* Src and tgt will be swapped if they do not conform to the direction of
|
||||
* the polycurve.
|
||||
*/
|
||||
X_monotone_curve_2 operator()(const X_monotone_curve_2& xcv,
|
||||
|
|
@ -424,7 +424,7 @@ namespace CGAL {
|
|||
/// @{
|
||||
|
||||
/*! Append a subcurve to the polycurve at the back.
|
||||
* \a Warning: This function does not preform the precondition test
|
||||
* \a Warning: This function does not perform the precondition test
|
||||
* that the `Push_back_2` functor does. Thus, it is
|
||||
* recommended to use the latter.
|
||||
* \param subcurve The new subcurve to be appended to the polycurve.
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ namespace CGAL {
|
|||
* curves, commonly referred to as polylines. Each polyline is a
|
||||
* chain of segments, where each two neighboring segments in the
|
||||
* chain share a common endpoint; that is, the polyline is
|
||||
* continuous. Furthermore, the target of the \f$i\f$th segement of
|
||||
* continuous. Furthermore, the target of the \f$i\f$th segment of
|
||||
* a polyline has to coincide with the source of the \f$i+1\f$st
|
||||
* segment; that is, the polyline has to be \a well-oriented. Note
|
||||
* that it is possible to construct general polylines that are
|
||||
|
|
|
|||
|
|
@ -8,9 +8,9 @@ namespace CGAL {
|
|||
* The `Arr_triangulation_point_location` class template implements a
|
||||
* point-location (and vertical ray-shooting) strategy that is based on
|
||||
* triangulation. In particular, the algorithm uses a constrained triangulation,
|
||||
* provided by the 2D Triangulations package, as a search strcture. Every time
|
||||
* provided by the 2D Triangulations package, as a search structure. Every time
|
||||
* the arrangement is modified the constrained triangulation search-structure is
|
||||
* reconstructed from scrach, where the edges of the arrangement are set to be
|
||||
* reconstructed from scratch, where the edges of the arrangement are set to be
|
||||
* the constrained edges of the triangulation. This strategy is inefficient
|
||||
* (especially when the number of modifications applied to the arrangement is
|
||||
* high) and provided only for educational purposes.
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ void insert_non_intersecting_curves(Arrangement_2<Traits,Dcel>& arr,
|
|||
*
|
||||
* Inserts a given point into a given arrangement. It uses a given
|
||||
* point-location object to locate the given point in the given arrangement. If
|
||||
* the point conincides with an existing vertex, there is nothing left to do; if
|
||||
* the point coincides with an existing vertex, there is nothing left to do; if
|
||||
* it lies on an edge, the edge is split at the point. Otherwise, the point is
|
||||
* contained inside a face, and is inserted as an isolated vertex inside this
|
||||
* face. By default, the function uses the "walk along line" point-location
|
||||
|
|
|
|||
|
|
@ -1185,7 +1185,7 @@ void insert_non_intersecting_curves
|
|||
*
|
||||
* Inserts a given point into a given arrangement. It uses a given
|
||||
* point-location object to locate the given point in the given arrangement. If
|
||||
* the point conincides with an existing vertex, there is nothing left to do; if
|
||||
* the point coincides with an existing vertex, there is nothing left to do; if
|
||||
* it lies on an edge, the edge is split at the point. Otherwise, the point is
|
||||
* contained inside a face, and is inserted as an isolated vertex inside this
|
||||
* face. By default, the function uses the "walk along line" point-location
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ public:
|
|||
* enumeration `ce` that specifies either the minimum or the maximum end of
|
||||
* the curve where the curve has a vertical asymptote, compares the \f$
|
||||
* x\f$-coordinate of `p` and the \f$x\f$-coordinate of the limit of the
|
||||
* curve at its specificed end. The variable `xcv` identifies the parametric
|
||||
* curve at its specified end. The variable `xcv` identifies the parametric
|
||||
* curve \f$c(t) = (x(t), y(t))\f$ defined over an open or half-open interval
|
||||
* with endpoints \f$ 0\f$ and \f$ 1\f$. The enumeration `ce` identifies an
|
||||
* open end \f$d \in\{0,1\}\f$ of \f$c\f$. Formally, compares the \f$
|
||||
|
|
@ -40,7 +40,7 @@ public:
|
|||
/*! Given two \f$ x\f$-monotone curves `xcv1` and `xcv2` and two indices `ce1`
|
||||
* and `ce2` that specify either the minimum or the maximum ends of `xcv1` and
|
||||
* `xcv2`, respectively, where the curves have vertical asymptotes, compares the
|
||||
* \f$ x\f$-coordinates of the limits of the curves at their specificed
|
||||
* \f$ x\f$-coordinates of the limits of the curves at their specified
|
||||
* ends. The variables `xcv1` and `xcv2` identify the parametric curves \f$
|
||||
* c_1(t) = (x_1(t),y_1(t))\f$ and \f$ c_2(t) = (x_2(t),y_2(t))\f$,
|
||||
* respectively, defined over open or half-open intervals with endpoints \f$
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ public:
|
|||
/// @{
|
||||
|
||||
/*! accepts two <I>mergeable</I> \f$ x\f$-monotone curves `xc1` and `xc2`
|
||||
* and asigns `xc` with the merged curve.
|
||||
* and assigns `xc` with the merged curve.
|
||||
*
|
||||
* \pre `are_mergeable_2`(`xc1`, `xc2`) is true.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
* (CCB). A face may be unbounded. Otherwise, it has one or more outer CCBs. A
|
||||
* face may also be bounded by inner CCBs, and it may contain isolated vertices
|
||||
* in its interior. A planar face may have only one outer CCBs and its inner
|
||||
* CCBs are refered to as holes.
|
||||
* CCBs are referred to as holes.
|
||||
*
|
||||
* \sa `ArrangementDcel`
|
||||
* \sa `ArrangementDcelVertex`
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ typedef unspecified_type template <class T> rebind;
|
|||
/// @{
|
||||
|
||||
/*!
|
||||
constructs an empty \dcel with one unbouned face.
|
||||
constructs an empty \dcel with one unbounded face.
|
||||
*/
|
||||
Arr_dcel();
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
* `ArrangementBasicTraits_2`. The arrangement template instantiated with a
|
||||
* traits class that models this concept can handle \f$ x\f$-monotone curves
|
||||
* that are unbounded in any direction. The concept
|
||||
* `ArrangementOpenBoundaryTraits_2`, nontheless, also supports planar \f$
|
||||
* `ArrangementOpenBoundaryTraits_2`, nonetheless, also supports planar \f$
|
||||
* x\f$-monotone curves that reach the boundary of an open yet bounded parameter
|
||||
* space.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
* <li> `CGAL::Arr_bounded_planar_topology_traits_2`—can serve as a topology traits
|
||||
* for an arrangement of planar unbounded curves.
|
||||
* <li> `CGAL::Arr_unb_planar_topology_traits_2`—can serve as a topology traits
|
||||
* for an arrangement of arcs of great circles embeded on a sphere.
|
||||
* for an arrangement of arcs of great circles embedded on a sphere.
|
||||
* </ul>
|
||||
*
|
||||
* At this point we do not expose all the requirements of this concept.
|
||||
|
|
@ -46,7 +46,7 @@ public:
|
|||
/*! constructs default. */
|
||||
Arr_topology_traits();
|
||||
|
||||
/*! construcs from a geometry-traits object. */
|
||||
/*! constructs from a geometry-traits object. */
|
||||
Arr_topology_traits(const Geometry_traits_2* geometry_traits);
|
||||
|
||||
/// @}
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ int main() {
|
|||
|
||||
// Insert a parabolic arc (C6) supported by the parabola y = -x^2 with
|
||||
// endpoints (-sqrt(3),-3) (~(-1.73,-3)) and (sqrt(2),-2) (~(1.41,-2)).
|
||||
// Since the x-coordinates of the endpoints cannot be acccurately represented,
|
||||
// Since the x-coordinates of the endpoints cannot be accurately represented,
|
||||
// we specify them as the intersections of the parabola with the lines
|
||||
// y = -3 and y = -2, respectively. The arc is clockwise-oriented.
|
||||
Conic_arc c6 =
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
#include "arr_linear.h"
|
||||
|
||||
// Define a functor for creating a label from a characer and an integer.
|
||||
// Define a functor for creating a label from a character and an integer.
|
||||
struct Overlay_label {
|
||||
std::string operator()(char c, unsigned int i) const
|
||||
{ return c + boost::lexical_cast<std::string>(i); }
|
||||
|
|
|
|||
|
|
@ -103,12 +103,12 @@ int main() {
|
|||
X_monotone_polycurve x_polycurve_1 =
|
||||
ctr_xcurve(x_curves.begin(), x_curves.end());
|
||||
|
||||
// Insert polycurves to Arangment and print.
|
||||
// Insert polycurves to Arrangement and print.
|
||||
Polycurve_circ_arc_arrangment polycurve_arrangment(&traits);
|
||||
insert(polycurve_arrangment, polycurve_1);
|
||||
insert(polycurve_arrangment, polycurve_2);
|
||||
insert(polycurve_arrangment, x_polycurve_1);
|
||||
std::cout << "Arrangment Statistics:\n";
|
||||
std::cout << "Arrangement Statistics:\n";
|
||||
print_arrangement(polycurve_arrangment);
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ int main() {
|
|||
X_monotone_polycurve conic_x_mono_polycurve_2 =
|
||||
ctr_xpolycurve(xmono_conic_curves_2.begin(), xmono_conic_curves_2.end());
|
||||
|
||||
// Insert the Polycurves into arrangment and print.
|
||||
// Insert the Polycurves into arrangement and print.
|
||||
Polycurve_conic_arrangment x_pc_arrangment(&traits);
|
||||
insert(x_pc_arrangment, conic_x_mono_polycurve_1);
|
||||
insert(x_pc_arrangment, conic_x_mono_polycurve_2);
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ public:
|
|||
m_owner (false)
|
||||
{}
|
||||
|
||||
/*! Assignmnet operator. */
|
||||
/*! Assignment operator. */
|
||||
Self& operator= (const Self& tr)
|
||||
{
|
||||
if (this == &tr)
|
||||
|
|
@ -809,7 +809,7 @@ public:
|
|||
m_traits.compare_y_at_x_2_object());
|
||||
CGAL_precondition_code(Equal_2 equal_2 = m_traits.equal_2_object());
|
||||
Compare_x_2 compare_x_2 = m_traits.compare_x_2_object();
|
||||
// Check whether source and taget are two distinct points and they lie
|
||||
// Check whether source and taeget are two distinct points and they lie
|
||||
// on the line.
|
||||
CGAL_precondition(compare_y_at_x_2(src, xcv) == EQUAL);
|
||||
CGAL_precondition(compare_y_at_x_2(tgt, xcv) == EQUAL);
|
||||
|
|
|
|||
|
|
@ -430,7 +430,7 @@ public:
|
|||
* Insert an x-monotone curve into the arrangement, such that one of its
|
||||
* endpoints corresponds to a given arrangement vertex, given the exact
|
||||
* place for the curve in the circular list around this vertex. The other
|
||||
* endpoint corrsponds to a free vertex (a newly created vertex or an
|
||||
* endpoint corresponds to a free vertex (a newly created vertex or an
|
||||
* isolated vertex).
|
||||
* \param he_to The reference halfedge. We should represent cv as a pair
|
||||
* of edges, one of them should become he_to's successor.
|
||||
|
|
@ -792,7 +792,7 @@ public:
|
|||
const Dcel& dcel() const { return (p_arr->_dcel()); }
|
||||
|
||||
/*!
|
||||
* Clear the entire arrangment.
|
||||
* Clear the entire arrangement.
|
||||
*/
|
||||
void clear_all()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ public:
|
|||
// Copy constructor
|
||||
Arr_algebraic_segment_traits_2 (const Self& /* s */) { /* No state...*/}
|
||||
|
||||
// Assignement operator
|
||||
// Assignment operator
|
||||
const Self& operator= (const Self& s)
|
||||
{return s;}
|
||||
|
||||
|
|
@ -254,7 +254,7 @@ public:
|
|||
return std::make_pair(std::make_pair(0,0),vertical);
|
||||
}
|
||||
|
||||
// abbrevation for convenience
|
||||
// abbreviation for convenience
|
||||
bool is_one_one(Curve_2 cv, Point_2 p) const {
|
||||
|
||||
std::pair<std::pair<int,int>,bool> branches
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
#include <CGAL/disable_warnings.h>
|
||||
|
||||
/*! \file
|
||||
* The header file for the Arr_circle_segment_traits_2<Kenrel> class.
|
||||
* The header file for the Arr_circle_segment_traits_2<Kernel> class.
|
||||
*/
|
||||
|
||||
#include <CGAL/tags.h>
|
||||
|
|
@ -421,7 +421,7 @@ public:
|
|||
return oi;
|
||||
}
|
||||
|
||||
// Check the case of a degenrate circle (a point).
|
||||
// Check the case of a degenerate circle (a point).
|
||||
const typename Kernel::Circle_2& circ = cv.supporting_circle();
|
||||
CGAL::Sign sign_rad = CGAL::sign (circ.squared_radius());
|
||||
CGAL_precondition (sign_rad != NEGATIVE);
|
||||
|
|
@ -702,7 +702,7 @@ public:
|
|||
m_traits.compare_y_at_x_2_object());
|
||||
CGAL_precondition_code(Equal_2 equal_2 = m_traits.equal_2_object());
|
||||
Compare_x_2 compare_x_2 = m_traits.compare_x_2_object();
|
||||
// Check whether source and taget are two distinct points and they lie
|
||||
// Check whether source and target are two distinct points and they lie
|
||||
// on the line.
|
||||
CGAL_precondition(compare_y_at_x_2(src, xcv) == EQUAL);
|
||||
CGAL_precondition(compare_y_at_x_2(tgt, xcv) == EQUAL);
|
||||
|
|
|
|||
|
|
@ -843,7 +843,7 @@ public:
|
|||
m_traits.compare_y_at_x_2_object());
|
||||
CGAL_precondition_code(Equal_2 equal_2 = m_traits.equal_2_object());
|
||||
Compare_x_2 compare_x_2 = m_traits.compare_x_2_object();
|
||||
// Check whether source and taget are two distinct points and they lie
|
||||
// Check whether source and target are two distinct points and they lie
|
||||
// on the line.
|
||||
CGAL_precondition(compare_y_at_x_2(src, xcv) == EQUAL);
|
||||
CGAL_precondition(compare_y_at_x_2(tgt, xcv) == EQUAL);
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
* A counting traits-class for the arrangement package.
|
||||
* This is a meta-traits class. It is parameterized with another traits class
|
||||
* and inherits from it. For each traits method it maintains a counter that
|
||||
* counts the number of invokations into the method.
|
||||
* counts the number of invocations into the method.
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
|
|
|
|||
|
|
@ -79,10 +79,10 @@ public:
|
|||
typedef typename internal::Arr_complete_right_side_category<Base_traits_2>::
|
||||
Category Right_side_category;
|
||||
|
||||
// Representation of a curve with an addtional data field:
|
||||
// Representation of a curve with an additonal data field:
|
||||
typedef _Curve_data_ex<Base_curve_2, Curve_data> Curve_2;
|
||||
|
||||
// Representation of an x-monotone curve with an addtional data field:
|
||||
// Representation of an x-monotone curve with an additonal data field:
|
||||
typedef _Curve_data_ex<Base_x_monotone_curve_2, X_monotone_curve_data>
|
||||
X_monotone_curve_2;
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ public:
|
|||
Arr_curve_data_traits_2(const Base_traits_2& traits) : Base_traits_2(traits) {}
|
||||
//@}
|
||||
|
||||
/// \name Overriden functors.
|
||||
/// \name Overridden functors.
|
||||
//@{
|
||||
|
||||
//! \name Intersections & subdivisions
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ public:
|
|||
|
||||
/*! Compare two points lexigoraphically: by x, then by y.
|
||||
* We actually reversing the order, so x <--> y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return true - y(p1) < y(p2);
|
||||
* true - y(p1) = y(p2) and x(p1) < x(p2);
|
||||
|
|
@ -129,7 +129,7 @@ public:
|
|||
|
||||
/*! Compare two points lexigoraphically: by y, then by x.
|
||||
* We actually reversing the order, so x <--> y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return true - x(p1) < x(p2);
|
||||
* true - x(p1) = x(p2) and y(p1) < y(p2);
|
||||
|
|
@ -250,7 +250,7 @@ public:
|
|||
|
||||
/*! Compare two points by y coordinate.
|
||||
* We actually reversing the order, so x <--> y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return SMALLER - x(p1) < x(p2);
|
||||
* EQUAL - x(p1) = x(p2);
|
||||
|
|
@ -395,7 +395,7 @@ public:
|
|||
|
||||
/*! Compare two points lexigoraphically: by x, then by y.
|
||||
* We actually reversing the order, so x <--> y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return true - y(p1) < y(p2);
|
||||
* true - y(p1) = y(p2) and x(p1) < x(p2);
|
||||
|
|
@ -436,7 +436,7 @@ public:
|
|||
|
||||
/*! Compare two points lexigoraphically: by y, then by x.
|
||||
* We actually reversing the order, so x <--> y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return true - x(p1) < x(p2);
|
||||
* true - x(p1) = x(p2) and y(p1) < y(p2);
|
||||
|
|
@ -556,7 +556,7 @@ public:
|
|||
|
||||
/*! Compare two points by y coordinate.
|
||||
* We actually reversing the order, so x <--> y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return SMALLER - x(p1) < x(p2);
|
||||
* EQUAL - x(p1) = x(p2);
|
||||
|
|
|
|||
|
|
@ -231,7 +231,7 @@ protected:
|
|||
|
||||
public:
|
||||
/*! Compare two endpoint directions by v.
|
||||
* \param d1 the first enpoint direction.
|
||||
* \param d1 the first endpoint direction.
|
||||
* \param d2 the second endpoint direction.
|
||||
* \return SMALLER - v(d1) < v(d2);
|
||||
* EQUAL - v(d1) = v(d2);
|
||||
|
|
@ -283,7 +283,7 @@ public:
|
|||
}
|
||||
|
||||
/*! Compare two endpoint directions by u.
|
||||
* \param d1 the first enpoint direction.
|
||||
* \param d1 the first endpoint direction.
|
||||
* \param d2 the second endpoint direction.
|
||||
* \return SMALLER - u(d1) < u(d2);
|
||||
* EQUAL - u(d1) = u(d2);
|
||||
|
|
@ -301,7 +301,7 @@ public:
|
|||
}
|
||||
|
||||
/*! Compare two endpoint directions lexigoraphically: by u, then by v.
|
||||
* \param d1 the first enpoint direction.
|
||||
* \param d1 the first endpoint direction.
|
||||
* \param d2 the second endpoint direction.
|
||||
* \return SMALLER - u(d1) < u(d2);
|
||||
* SMALLER - u(d1) = u(d2) and v(d1) < v(d2);
|
||||
|
|
@ -640,7 +640,7 @@ public:
|
|||
return;
|
||||
}
|
||||
|
||||
// None of the enpoints coincide with a pole:
|
||||
// None of the endpoints coincide with a pole:
|
||||
Direction_2 s = Traits::project_xy(source);
|
||||
Direction_2 t = Traits::project_xy(target);
|
||||
|
||||
|
|
@ -763,7 +763,7 @@ public:
|
|||
return cv;
|
||||
}
|
||||
|
||||
// None of the enpoints coincide with a pole:
|
||||
// None of the endpoints coincide with a pole:
|
||||
if (z_sign(normal) == ZERO) {
|
||||
// The arc is vertical
|
||||
cv.set_is_vertical(true);
|
||||
|
|
@ -992,8 +992,8 @@ public:
|
|||
};
|
||||
|
||||
protected:
|
||||
/*! Obtain the possitive (north) pole
|
||||
* \return the possitive (north) pole
|
||||
/*! Obtain the positive (north) pole
|
||||
* \return the positive (north) pole
|
||||
*/
|
||||
inline static const Point_2& pos_pole()
|
||||
{
|
||||
|
|
@ -1033,7 +1033,7 @@ public:
|
|||
|
||||
public:
|
||||
/*! Compare two directional points lexigoraphically: by x, then by y.
|
||||
* \param p1 the first enpoint directional point.
|
||||
* \param p1 the first endpoint directional point.
|
||||
* \param p2 the second endpoint directional point.
|
||||
* \return SMALLER - x(p1) < x(p2);
|
||||
* SMALLER - x(p1) = x(p2) and y(p1) < y(p2);
|
||||
|
|
@ -2140,7 +2140,7 @@ public:
|
|||
return oi;
|
||||
}
|
||||
|
||||
// None of the enpoints coincide with a pole.
|
||||
// None of the endpoints coincide with a pole.
|
||||
bool s_is_positive, t_is_positive, plane_is_positive;
|
||||
CGAL::Sign xsign = Traits::x_sign(normal);
|
||||
if (xsign == ZERO) {
|
||||
|
|
@ -2172,7 +2172,7 @@ public:
|
|||
return oi;
|
||||
}
|
||||
|
||||
// The curve is not vertical, (none of the enpoints coincide with a pole)
|
||||
// The curve is not vertical, (none of the endpoints coincide with a pole)
|
||||
Direction_3 dp;
|
||||
m_traits.intersection_with_identification(c, dp, Zero_atan_y());
|
||||
Point_2 p(dp, Point_2::MID_BOUNDARY_LOC);
|
||||
|
|
@ -2589,7 +2589,7 @@ public:
|
|||
return oi;
|
||||
}
|
||||
|
||||
/*! If the endpoints of one arc coinside with the 2 poles resp,
|
||||
/*! If the endpoints of one arc coincide with the 2 poles resp,
|
||||
* the other arc is completely overlapping.
|
||||
*/
|
||||
if (xc1.left().is_min_boundary() && xc1.right().is_max_boundary()) {
|
||||
|
|
@ -3166,7 +3166,7 @@ public:
|
|||
return;
|
||||
}
|
||||
|
||||
// None of the enpoints coincide with a pole:
|
||||
// None of the endpoints coincide with a pole:
|
||||
Direction_2 s = Traits::project_xy(m_source);
|
||||
Direction_2 t = Traits::project_xy(m_target);
|
||||
|
||||
|
|
|
|||
|
|
@ -211,7 +211,7 @@ intersect(const Arr_plane_3<Kernel> & plane1,
|
|||
typedef typename Kernel::FT FT;
|
||||
typedef boost::variant<Line_3, Arr_plane_3<Kernel> > Intersection_result;
|
||||
|
||||
// We know that the plane goes throgh the origin
|
||||
// We know that the plane goes through the origin
|
||||
const FT& a1 = plane1.a();
|
||||
const FT& b1 = plane1.b();
|
||||
const FT& c1 = plane1.c();
|
||||
|
|
|
|||
|
|
@ -719,7 +719,7 @@ public:
|
|||
|
||||
/*!
|
||||
* Construct a bounding box for the given control polygon.
|
||||
* \param cp A sequence of control point (the control polgon).
|
||||
* \param cp A sequence of control point (the control polygon).
|
||||
* \param bbox Output: The bounding box.
|
||||
* \pre cp is not empty.
|
||||
*/
|
||||
|
|
@ -776,7 +776,7 @@ private:
|
|||
Comparison_result res = EQUAL;
|
||||
|
||||
// Look for the first pair of consecutive points whose x-coordinate
|
||||
// (or y-coordinate) are not equal. Their comparsion result will be
|
||||
// (or y-coordinate) are not equal. Their comparison result will be
|
||||
// set as the "reference" comparison result.
|
||||
typename Control_points::const_iterator pt_curr = cp.begin();
|
||||
typename Control_points::const_iterator pt_end = cp.end();
|
||||
|
|
@ -1054,7 +1054,7 @@ private:
|
|||
const Point_2& s2 = cp2.front();
|
||||
const Point_2& t2 = cp2.back();
|
||||
|
||||
// Check whether any pair of these endpoints conincide.
|
||||
// Check whether any pair of these endpoints coincide.
|
||||
NT x, y; // Coordinate of a common endpoint.
|
||||
NT t_val1, t_val2; // Its respective parameters.
|
||||
|
||||
|
|
@ -1114,7 +1114,7 @@ private:
|
|||
}
|
||||
|
||||
/*!
|
||||
* An auxilary recursive function for computing the approximated
|
||||
* An auxiliary recursive function for computing the approximated
|
||||
* intersection points between two Bezier curves.
|
||||
* \param cp1 The control points of the first curve.
|
||||
* \param t_min1 The lower bound of the parameter range of the first curve.
|
||||
|
|
@ -1369,7 +1369,7 @@ private:
|
|||
}
|
||||
|
||||
/*!
|
||||
* An auxilary recursive function for computing the approximated vertical
|
||||
* An auxiliary recursive function for computing the approximated vertical
|
||||
* tangency points of a Bezier curves.
|
||||
* \param cp The control points of the curve.
|
||||
* \param t_min The lower bound of the parameter range of the curve.
|
||||
|
|
|
|||
|
|
@ -822,7 +822,7 @@ _Bezier_cache<NtTraits>::_compute_resultant
|
|||
}
|
||||
|
||||
// We multiplied the current row by the i'th diagonal entry, thus
|
||||
// multipling the determinant value by it. We therefore increment
|
||||
// multiplying the determinant value by it. We therefore increment
|
||||
// the exponent of mat[i][i] in the normalization factor.
|
||||
exp_fact[i] = exp_fact[i] + 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ public:
|
|||
|
||||
for (k = 0; pts_begin != pts_end; ++pts_begin, k++)
|
||||
{
|
||||
//SL: Acccording to the fact that all operations are based on polynomials
|
||||
//SL: According to the fact that all operations are based on polynomials
|
||||
// duplicated control points can be allowed.
|
||||
// // Make sure that we do not have two identical consecutive control
|
||||
// // points.
|
||||
|
|
@ -423,7 +423,7 @@ public:
|
|||
}
|
||||
|
||||
/*!
|
||||
* Get an interator for the first control point.
|
||||
* Get an iterator for the first control point.
|
||||
*/
|
||||
Control_point_iterator control_points_begin () const
|
||||
{
|
||||
|
|
@ -431,7 +431,7 @@ public:
|
|||
}
|
||||
|
||||
/*!
|
||||
* Get a past-the-end interator for control points.
|
||||
* Get a past-the-end iterator for control points.
|
||||
*/
|
||||
Control_point_iterator control_points_end () const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ private:
|
|||
unsigned int _xid; /*!< Serial number of the originating
|
||||
x-monotone curve. */
|
||||
Bez_point_bound _bpb; /*!< Bounding information for the
|
||||
point: bouding control polygon,
|
||||
point: bounding control polygon,
|
||||
point type, etc. */
|
||||
Algebraic *p_t; /*!< The algebraic parameter for the
|
||||
point (if available). */
|
||||
|
|
@ -240,7 +240,7 @@ private:
|
|||
* Set the serial number of the originating x-monotone curve.
|
||||
* \param xid the new serial number of the originating x-monotone curve.
|
||||
* \pre The current xid() is 0.
|
||||
* \pre xid is possitive.
|
||||
* \pre xid is positive.
|
||||
*/
|
||||
void set_xid (unsigned int xid)
|
||||
{
|
||||
|
|
@ -253,7 +253,7 @@ private:
|
|||
};
|
||||
|
||||
/*! \struct Subcurve
|
||||
* Auxilary structure for the vertical_position() function.
|
||||
* Auxiliary structure for the vertical_position() function.
|
||||
*/
|
||||
typedef typename Bounding_traits::Control_points Control_points;
|
||||
typedef typename Bounding_traits::NT BoundNT;
|
||||
|
|
@ -1421,7 +1421,7 @@ bool _Bezier_point_2_rep<RatKer, AlgKer, NtTrt, BndTrt>::_refine ()
|
|||
CGAL_assertion(_origs.size() == 2);
|
||||
|
||||
// Obtain the other curve that originates the intersection point and use
|
||||
// it to refine its reprsentation.
|
||||
// it to refine its representation.
|
||||
Orig_iter org_it = _origs.begin();
|
||||
++org_it;
|
||||
Originator& orig2 = *org_it;
|
||||
|
|
|
|||
|
|
@ -533,7 +533,7 @@ private:
|
|||
/*! Compute the exact vertical position of the given point with respect to
|
||||
* the x-monotone curve.
|
||||
* \param p The point.
|
||||
* \param force_exact Sould we force an exact result.
|
||||
* \param force_exact Should we force an exact result.
|
||||
* \return SMALLER if the point is below the curve;
|
||||
* LARGER if the point is above the curve;
|
||||
* EQUAL if p lies on the curve.
|
||||
|
|
@ -751,7 +751,7 @@ point_position(const Point_2& p, Bezier_cache& cache) const
|
|||
in_range = _is_in_range(p, correct_res);
|
||||
|
||||
if (! correct_res) {
|
||||
// Perform the comparsion in an exact manner.
|
||||
// Perform the comparison in an exact manner.
|
||||
if (! p.is_exact())
|
||||
p.make_exact(cache);
|
||||
|
||||
|
|
@ -764,7 +764,7 @@ point_position(const Point_2& p, Bezier_cache& cache) const
|
|||
}
|
||||
|
||||
// Call the vertical-position function that uses the bounding-boxes
|
||||
// to evaluate the comparsion result.
|
||||
// to evaluate the comparison result.
|
||||
typename Bounding_traits::Control_points cp;
|
||||
|
||||
std::copy(_curve.control_points_begin(), _curve.control_points_end(),
|
||||
|
|
@ -1192,7 +1192,7 @@ _Bezier_x_monotone_2<RatKer, AlgKer, NtTrt, BndTrt>::compare_to_left
|
|||
return (slope_res);
|
||||
|
||||
// Compare the two subcurves by choosing some point to the left of p
|
||||
// and compareing the vertical position there.
|
||||
// and comparing the vertical position there.
|
||||
Comparison_result left_res;
|
||||
|
||||
if (left().compare_x(cv.left(), cache) != SMALLER)
|
||||
|
|
@ -1376,7 +1376,7 @@ _is_in_range(const Algebraic& t, Bezier_cache& cache) const
|
|||
return (false);
|
||||
}
|
||||
|
||||
// Obtain the exact t-range of the curve and peform an exact comparison.
|
||||
// Obtain the exact t-range of the curve and perform an exact comparison.
|
||||
std::pair<Algebraic, Algebraic> range = _t_range (cache);
|
||||
const Algebraic& t_src = range.first;
|
||||
const Algebraic& t_trg = range.second;
|
||||
|
|
@ -1923,7 +1923,7 @@ _clip_control_polygon(typename Bounding_traits::Control_points& ctrl,
|
|||
if (! (org_min->point_bound().type == Bez_point_bound::RATIONAL_PT &&
|
||||
CGAL::sign(org_min->point_bound().t_min) == CGAL::ZERO))
|
||||
{
|
||||
// It is possible that the paramater range of the originator is too large.
|
||||
// It is possible that the parameter range of the originator is too large.
|
||||
// We therefore make sure it fits the current bounding box of the point
|
||||
// (which we know is tight enough).
|
||||
p_min.fit_to_bbox();
|
||||
|
|
@ -1951,7 +1951,7 @@ _clip_control_polygon(typename Bounding_traits::Control_points& ctrl,
|
|||
if (! (org_max->point_bound().type == Bez_point_bound::RATIONAL_PT &&
|
||||
CGAL::compare (org_max->point_bound().t_max, 1) == CGAL::EQUAL))
|
||||
{
|
||||
// It is possible that the paramater range of the originator is too large.
|
||||
// It is possible that the parameter range of the originator is too large.
|
||||
// We therefore make sure it fits the current bounding box of the point
|
||||
// (which we know is tight enough).
|
||||
p_max.fit_to_bbox();
|
||||
|
|
@ -2435,7 +2435,7 @@ _exact_vertical_position(const Point_2& p,
|
|||
#endif
|
||||
) const
|
||||
{
|
||||
// If it is a rational point, obtain its rational reprsentation.
|
||||
// If it is a rational point, obtain its rational representation.
|
||||
Rat_point_2 rat_p;
|
||||
|
||||
if (p.is_rational())
|
||||
|
|
|
|||
|
|
@ -1705,7 +1705,7 @@ protected:
|
|||
}
|
||||
|
||||
/*! Compute the intersections between the supporting circle of (*this) and
|
||||
* the supporting line of the segement cv.
|
||||
* the supporting line of the segment cv.
|
||||
*/
|
||||
void _circ_line_intersect(const Self& cv,
|
||||
Intersection_list& inter_list) const
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ public:
|
|||
_target (target),
|
||||
_extra_data_P (nullptr)
|
||||
{
|
||||
// Make sure that the source and the taget are not the same.
|
||||
// Make sure that the source and the target are not the same.
|
||||
CGAL_precondition (Alg_kernel().compare_xy_2_object() (source,
|
||||
target) != EQUAL);
|
||||
|
||||
|
|
@ -249,7 +249,7 @@ public:
|
|||
_source = Point_2 (nt_traits.convert (x1), nt_traits.convert (y1));
|
||||
_target = Point_2 (nt_traits.convert (x2), nt_traits.convert (y2));
|
||||
|
||||
// Make sure that the source and the taget are not the same.
|
||||
// Make sure that the source and the target are not the same.
|
||||
CGAL_precondition (Alg_kernel().compare_xy_2_object() (_source,
|
||||
_target) != EQUAL);
|
||||
|
||||
|
|
@ -300,7 +300,7 @@ public:
|
|||
Rational y0 = center.y();
|
||||
Rational R_sqr = ker.compute_squared_radius_2_object() (circ);
|
||||
|
||||
// Produce the correponding conic: if the circle center is (x0,y0)
|
||||
// Produce the corresponding conic: if the circle center is (x0,y0)
|
||||
// and its squared radius is R^2, that its equation is:
|
||||
// x^2 + y^2 - 2*x0*x - 2*y0*y + (x0^2 + y0^2 - R^2) = 0
|
||||
// Note that this equation describes a curve with a negative (clockwise)
|
||||
|
|
@ -338,7 +338,7 @@ public:
|
|||
_target(target),
|
||||
_extra_data_P (nullptr)
|
||||
{
|
||||
// Make sure that the source and the taget are not the same.
|
||||
// Make sure that the source and the target are not the same.
|
||||
CGAL_precondition (Alg_kernel().compare_xy_2_object() (source,
|
||||
target) != EQUAL);
|
||||
CGAL_precondition (orient != COLLINEAR);
|
||||
|
|
@ -350,7 +350,7 @@ public:
|
|||
Rational y0 = center.y();
|
||||
Rational R_sqr = ker.compute_squared_radius_2_object() (circ);
|
||||
|
||||
// Produce the correponding conic: if the circle center is (x0,y0)
|
||||
// Produce the corresponding conic: if the circle center is (x0,y0)
|
||||
// and it squared radius is R^2, that its equation is:
|
||||
// x^2 + y^2 - 2*x0*x - 2*y0*y + (x0^2 + y0^2 - R^2) = 0
|
||||
// Since this equation describes a curve with a negative (clockwise)
|
||||
|
|
@ -412,7 +412,7 @@ public:
|
|||
_source = Point_2 (nt_traits.convert (x1), nt_traits.convert (y1));
|
||||
_target = Point_2 (nt_traits.convert (x3), nt_traits.convert (y3));
|
||||
|
||||
// Make sure that the source and the taget are not the same.
|
||||
// Make sure that the source and the target are not the same.
|
||||
CGAL_precondition (Alg_kernel().compare_xy_2_object() (_source,
|
||||
_target) != EQUAL);
|
||||
|
||||
|
|
@ -440,7 +440,7 @@ public:
|
|||
|
||||
if (points_collinear)
|
||||
{
|
||||
_info = 0; // Inavlid arc.
|
||||
_info = 0; // Invalid arc.
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -506,7 +506,7 @@ public:
|
|||
|
||||
if (point_collinear)
|
||||
{
|
||||
_info = 0; // Inavlid arc.
|
||||
_info = 0; // Invalid arc.
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -943,7 +943,7 @@ public:
|
|||
}
|
||||
else
|
||||
{
|
||||
// Use the source and target to initialize the exterme points.
|
||||
// Use the source and target to initialize the extreme points.
|
||||
bool source_left =
|
||||
CGAL::to_double(_source.x()) < CGAL::to_double(_target.x());
|
||||
x_min = source_left ?
|
||||
|
|
@ -1270,7 +1270,7 @@ private:
|
|||
else
|
||||
{
|
||||
// The sign of (4rs - t^2) detetmines the conic type:
|
||||
// - if it is possitive, the conic is an ellipse,
|
||||
// - if it is positive, the conic is an ellipse,
|
||||
// - if it is negative, the conic is a hyperbola,
|
||||
// - if it is zero, the conic is a parabola.
|
||||
CGAL::Sign sign_conic = CGAL::sign (4*_r*_s - _t*_t);
|
||||
|
|
@ -1371,7 +1371,7 @@ private:
|
|||
}
|
||||
|
||||
/*!
|
||||
* Build the data for hyperbolic arc, contaning the characterization of the
|
||||
* Build the data for hyperbolic arc, containing the characterization of the
|
||||
* hyperbolic branch the arc is placed on.
|
||||
*/
|
||||
void _build_hyperbolic_arc_data ()
|
||||
|
|
@ -1626,7 +1626,7 @@ protected:
|
|||
}
|
||||
|
||||
/*!
|
||||
* Find the vertical tangency points of the undelying conic.
|
||||
* Find the vertical tangency points of the underlying conic.
|
||||
* \param ps The output points of vertical tangency.
|
||||
* This area must be allocated at the size of 2.
|
||||
* \return The number of vertical tangency points.
|
||||
|
|
@ -1709,7 +1709,7 @@ protected:
|
|||
}
|
||||
|
||||
/*!
|
||||
* Find the horizontal tangency points of the undelying conic.
|
||||
* Find the horizontal tangency points of the underlying conic.
|
||||
* \param ps The output points of horizontal tangency.
|
||||
* This area must be allocated at the size of 2.
|
||||
* \return The number of horizontal tangency points.
|
||||
|
|
|
|||
|
|
@ -111,12 +111,12 @@ private:
|
|||
Base()
|
||||
{}
|
||||
|
||||
/*! Constrcutor from the base class. */
|
||||
/*! Constructor from the base class. */
|
||||
_Conic_point_2 (const Base& p) :
|
||||
Base (p)
|
||||
{}
|
||||
|
||||
/*! Constructor with homegeneous coordinates. */
|
||||
/*! Constructor with homogeneous coordinates. */
|
||||
_Conic_point_2 (const Algebraic& hx,
|
||||
const Algebraic& hy,
|
||||
const Algebraic& hz) :
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ protected:
|
|||
|
||||
public:
|
||||
|
||||
/// \name Constrcution methods.
|
||||
/// \name Construction methods.
|
||||
//@{
|
||||
|
||||
/*!
|
||||
|
|
@ -945,7 +945,7 @@ public:
|
|||
|
||||
/*!
|
||||
* Flip the arc.
|
||||
* \return An arc with swapped source and target and a reverse orienation.
|
||||
* \return An arc with swapped source and target and a reverse orientation.
|
||||
*/
|
||||
Self flip() const
|
||||
{
|
||||
|
|
@ -1218,7 +1218,7 @@ private:
|
|||
|
||||
// Check whether the conic is facing up or facing down:
|
||||
// Check whether the arc (which is x-monotone of degree 2) lies above or
|
||||
// below the segement that contects its two end-points (x1,y1) and (x2,y2).
|
||||
// below the segment that connects its two end-points (x1,y1) and (x2,y2).
|
||||
// To do that, we find the y coordinate of a point on the arc whose x
|
||||
// coordinate is (x1+x2)/2 and compare it to (y1+y2)/2.
|
||||
Comparison_result res = ker.compare_y_2_object() (p_arc_mid, p_mid);
|
||||
|
|
@ -1239,7 +1239,7 @@ private:
|
|||
|
||||
/*!
|
||||
* Check if the arc is a special segment connecting two algebraic endpoints
|
||||
* (and has no undelying integer conic coefficients).
|
||||
* (and has no underlying integer conic coefficients).
|
||||
*/
|
||||
bool _is_special_segment () const
|
||||
{
|
||||
|
|
@ -1679,7 +1679,7 @@ private:
|
|||
}
|
||||
|
||||
/*!
|
||||
* Intersect the supporing conic curves of this arc and the given arc.
|
||||
* Intersect the supporting conic curves of this arc and the given arc.
|
||||
* \param arc The arc to intersect with.
|
||||
* \param inter_list The list of intersection points.
|
||||
*/
|
||||
|
|
@ -1703,7 +1703,7 @@ private:
|
|||
if (arc._is_special_segment()) {
|
||||
// The second arc is a special segment (a*x + b*y + c = 0).
|
||||
if (_is_special_segment()) {
|
||||
// Both arc are sepcial segment, so they have at most one intersection
|
||||
// Both arc are special segment, so they have at most one intersection
|
||||
// point.
|
||||
Algebraic denom = this->_extra_data_P->a * arc._extra_data_P->b -
|
||||
this->_extra_data_P->b * arc._extra_data_P->a;
|
||||
|
|
|
|||
|
|
@ -474,7 +474,7 @@ CGAL::Comparison_result compare (const _One_root_number<NT, FL>& x,
|
|||
sign_right = ZERO;
|
||||
}
|
||||
|
||||
// Check whether on of the terms is zero. In this case, the comparsion
|
||||
// Check whether on of the terms is zero. In this case, the comparison
|
||||
// result is simpler:
|
||||
if (sign_left == ZERO)
|
||||
{
|
||||
|
|
@ -507,7 +507,7 @@ CGAL::Comparison_result compare (const _One_root_number<NT, FL>& x,
|
|||
// We now square both terms and look at the sign of the one-root number:
|
||||
// ((a1 - a2)^2 - (b1^2*c1 + b2^2*c2)) + 2*b1*b2*sqrt(c1*c2)
|
||||
//
|
||||
// If both signs are negative, we should swap the comparsion result
|
||||
// If both signs are negative, we should swap the comparison result
|
||||
// we eventually compute.
|
||||
const NT A = diff_alpha*diff_alpha - (x_sqr + y_sqr);
|
||||
const NT B = 2 * x.beta() * y.beta();
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ protected:
|
|||
|
||||
public:
|
||||
|
||||
/// \name Constrcution methods.
|
||||
/// \name Construction methods.
|
||||
//@{
|
||||
|
||||
/*!
|
||||
|
|
@ -339,7 +339,7 @@ public:
|
|||
if (! valid)
|
||||
return;
|
||||
|
||||
// Analyze the bahaviour of the rational function at x = -oo (the source).
|
||||
// Analyze the behaviour 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 bahaviour of the rational function at x = +oo (the target).
|
||||
// Analyze the behaviour of the rational function at x = +oo (the target).
|
||||
const Arr_parameter_space inf_t =
|
||||
_analyze_at_plus_infinity (_numer, _denom, y0);
|
||||
|
||||
|
|
@ -989,7 +989,7 @@ public:
|
|||
|
||||
// Both arcs are defined to the same side (left or right) of the vertical
|
||||
// asymptote. If one is defined at y = -oo and the other at y = +oo, we
|
||||
// preform a "lexicographic" comparison.
|
||||
// perform a "lexicographic" comparison.
|
||||
const Arr_parameter_space inf_y1 =
|
||||
(ind1 == ARR_MIN_END ? left_infinite_in_y() : right_infinite_in_y());
|
||||
const Arr_parameter_space inf_y2 = (ind2 == ARR_MIN_END) ?
|
||||
|
|
@ -1833,7 +1833,7 @@ public:
|
|||
typedef std::pair<Point_2,Multiplicity> Intersection_point;
|
||||
|
||||
|
||||
/// \name Constrcution methods.
|
||||
/// \name Construction methods.
|
||||
//@{
|
||||
|
||||
/*!
|
||||
|
|
@ -1844,7 +1844,7 @@ public:
|
|||
{}
|
||||
|
||||
/*!
|
||||
* Constrcutor from a base arc.
|
||||
* Constructor from a base arc.
|
||||
*/
|
||||
_Continuous_rational_arc_2 (const Base& arc) :
|
||||
Base (arc)
|
||||
|
|
@ -2346,7 +2346,7 @@ public:
|
|||
typedef typename Base::Rat_vector Rat_vector;
|
||||
typedef typename Base::Polynomial Polynomial;
|
||||
|
||||
/// \name Constrcution methods.
|
||||
/// \name Construction methods.
|
||||
//@{
|
||||
|
||||
/*!
|
||||
|
|
|
|||
|
|
@ -262,7 +262,7 @@ protected:
|
|||
* \param new_vertex Output: if found a closer vertex to the query point.
|
||||
* \param cv_is_contained_in_seg Output: Whether cv is contained inside seg.
|
||||
* \return A handle to the halfedge (if no intersecting edge is found, the
|
||||
* function returns an ivalid halfedge handle).
|
||||
* function returns an invalid halfedge handle).
|
||||
*/
|
||||
Halfedge_const_handle
|
||||
_intersection_with_ccb(Ccb_halfedge_const_circulator circ,
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue