mirror of https://github.com/CGAL/cgal
Spelling corrections
Last batch (for now) of spelling corrections in doxygen and normal comments
This commit is contained in:
albert-github
parent
5ffa817b62
commit
36c8b7589d
|
|
@ -575,13 +575,13 @@ If the `UsePolylines` template parameter is substitited with
|
|||
|
||||
<li>Instead of using an instance of the `Polygon_set_2` class
|
||||
template, as described above, an instance of the
|
||||
`General_polygon_set_2` class template is used, which utilzes the
|
||||
`General_polygon_set_2` class template is used, which utilizes the
|
||||
`Arr_polyline_traits_2` class template; see Section \ref
|
||||
arr_ssectr_polylines in the 2D Arrangements package.
|
||||
|
||||
<li>Each input linear polygon (respectively linear polygon with holes) is
|
||||
converted into a general polygon (respectively general polygon with holes)
|
||||
bounded by \f$x\f$-monotone polylines. Then, the resulting generl
|
||||
bounded by \f$x\f$-monotone polylines. Then, the resulting general
|
||||
polygons, which are also bounded by \f$x\f$-monotone polylines, are
|
||||
converted back to standard polygons.
|
||||
|
||||
|
|
|
|||
|
|
@ -691,7 +691,7 @@ bool are_holes_and_boundary_pairwise_disjoint
|
|||
bool intersect = gps.do_intersect(hole);
|
||||
if (intersect) return false;
|
||||
else {
|
||||
/* to use gps.insert(hole) it is required that the set coponents and the
|
||||
/* to use gps.insert(hole) it is required that the set components and the
|
||||
* new holes do not intersect.
|
||||
* because the sweep detects shared edges and the do_intersect query
|
||||
* detects 2D intersections we can safely use the insert(pwh) function
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ struct _Less_handle
|
|||
|
||||
/*!
|
||||
* Connect the given polygon with holes, turning it into a sequence of
|
||||
* points, where the holes are connceted to the outer boundary using
|
||||
* points, where the holes are connected to the outer boundary using
|
||||
* zero-width passages.
|
||||
* For example:
|
||||
* Input Output
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ namespace CGAL {
|
|||
// where alpha = (1+a_eps)(d+1) with a_eps the return value
|
||||
// of achieved_epsilon().
|
||||
//
|
||||
// The ellipsoid E* we actuallly want is the intersection of E' with
|
||||
// The ellipsoid E* we actually want is the intersection of E' with
|
||||
// the hyperplane { (y,z) in R^{d+1} | y = 1}. Writing
|
||||
//
|
||||
// [ M' m ] [ y ]
|
||||
|
|
|
|||
|
|
@ -794,7 +794,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
if (d.is_middle_empty()) {
|
||||
|
||||
// now try to position the bottom piercing point in each
|
||||
// of the intervalls formed by S_bt and S_br
|
||||
// of the intervals formed by S_bt and S_br
|
||||
// (no need to consider S_bl, since we move from left
|
||||
// to right and leaving a rectangle won't make piercing easier)
|
||||
|
||||
|
|
@ -813,7 +813,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
Citerator br = d.brstc_begin();
|
||||
Citerator rt = d.rtstc_begin();
|
||||
|
||||
// make sure the top intervall is covered (left endpoint)
|
||||
// make sure the top interval is covered (left endpoint)
|
||||
// (it might be that top_i.first determines the placement of
|
||||
// the top square)
|
||||
Point_2 top = top_i.first;
|
||||
|
|
@ -826,14 +826,14 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
if (tl != d.tlstc_end()) {
|
||||
for (;;) {
|
||||
|
||||
// make sure the top intervall is covered (right endpoint)
|
||||
// make sure the top interval is covered (right endpoint)
|
||||
if (sdistx(top_i.second, top) > FT(2) * d.r)
|
||||
break;
|
||||
|
||||
// compute position of left square
|
||||
Point_2 left = lessy(left_i.second, *tl) ? *tl : left_i.second;
|
||||
|
||||
// make sure the left intervall is covered
|
||||
// make sure the left interval is covered
|
||||
if (sdisty(left, left_i.first) <= FT(2) * d.r) {
|
||||
|
||||
// compute position of bottom square
|
||||
|
|
@ -844,7 +844,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
break;
|
||||
Point_2 bottom = lessx(bottom_i.first, *lb) ? bottom_i.first : *lb;
|
||||
|
||||
// check the shared x-intervall
|
||||
// check the shared x-interval
|
||||
if (!share.empty() && d.is_x_greater_y()) {
|
||||
// compute position of top in share
|
||||
#ifndef _MSC_VER
|
||||
|
|
@ -862,7 +862,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
sdistx(*(shl - 1), top) > FT(2) * d.r)
|
||||
--shl;
|
||||
|
||||
// make sure shared intervall is covered (left endpoint)
|
||||
// make sure shared interval is covered (left endpoint)
|
||||
#ifndef _MSC_VER
|
||||
if ((shf != share.begin() || shl == share.end()) &&
|
||||
lessx(share.front(), bottom))
|
||||
|
|
@ -881,7 +881,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
}
|
||||
|
||||
|
||||
// make sure the bottom and the shared intervall (right endpoint)
|
||||
// make sure the bottom and the shared interval (right endpoint)
|
||||
// are covered
|
||||
#ifndef _MSC_VER
|
||||
if (sdistx(bottom_i.second, bottom) <= FT(2) * d.r &&
|
||||
|
|
@ -907,7 +907,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
break;
|
||||
Point_2 right = lessy(right_i.first, *br) ? right_i.first : *br;
|
||||
|
||||
// check the shared y-intervall
|
||||
// check the shared y-interval
|
||||
if (!share.empty() && !d.is_x_greater_y()) {
|
||||
// compute position of left in share
|
||||
#ifndef _MSC_VER
|
||||
|
|
@ -926,7 +926,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
lessy(left, *(shl - 1)))
|
||||
--shl;
|
||||
|
||||
// make sure shared intervall is covered (bottom endpoint)
|
||||
// make sure shared interval is covered (bottom endpoint)
|
||||
#ifndef _MSC_VER
|
||||
if ((shf != share.begin() || shl == share.end()) &&
|
||||
lessy(share.front(), right))
|
||||
|
|
@ -945,7 +945,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
}
|
||||
|
||||
|
||||
// make sure the right intervall and the shared intervall
|
||||
// make sure the right interval and the shared interval
|
||||
// (top endpoint) are covered
|
||||
#ifndef _MSC_VER
|
||||
if (sdisty(right_i.second, right) <= FT(2) * d.r &&
|
||||
|
|
@ -985,7 +985,7 @@ four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok)
|
|||
|
||||
} // if (sdisty(right_i.second, right) <= FT(2) * d.r)
|
||||
|
||||
} // if (bottom and shared intervall are covered)
|
||||
} // if (bottom and shared interval are covered)
|
||||
|
||||
} // if (sdisty(left, left_i.first) <= FT(2) * d.r)
|
||||
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ public:
|
|||
return rep->clLgErr();
|
||||
}
|
||||
|
||||
/// division with relative precsion <tt>r</tt>
|
||||
/// division with relative precision <tt>r</tt>
|
||||
BigFloat div(const BigFloat& x, const extLong& r) const {
|
||||
BigFloat y;
|
||||
y.rep->div(*rep, *x.rep, r);
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ public:
|
|||
CGAL_CORE_finite(fpVal) && // Test for infinite and NaNs
|
||||
(core_abs(fpVal) >= maxAbs*ind*CORE_EPS));
|
||||
}
|
||||
/// return the sign of fitered value.
|
||||
/// return the sign of filtered value.
|
||||
/** (Note: must call isOK() to check whether the sign is ok
|
||||
before call this function.) */
|
||||
int sign() const {
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ void nngIpelet::protected_run(int fn)
|
|||
++v){
|
||||
|
||||
std::vector<Triangulation::Vertex_handle> kNN;
|
||||
CGAL::nearest_neighbors(t, v, kNeighbors+1, std::back_inserter(kNN)); // +1 as v itself counts as its nearest neigbhor for CGAL::nearest_neighbors
|
||||
CGAL::nearest_neighbors(t, v, kNeighbors+1, std::back_inserter(kNN)); // +1 as v itself counts as its nearest neighbor for CGAL::nearest_neighbors
|
||||
|
||||
for(const auto & nn : kNN) {
|
||||
if(v->point() != nn->point()) {
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ Stuff to look at, as time permits:
|
|||
|
||||
- Why Ray_3 and Line_3 don't have the same internal representation ???
|
||||
|
||||
- Triangle-Triangle instersection (and predicate) :
|
||||
- Triangle-Triangle intersection (and predicate) :
|
||||
Tomas Möller. A fast triangle-triangle intersection test. Journal of
|
||||
Graphics Tools, 2(2):25-30, 1997
|
||||
A Fast Triangle-Triangle Intersection Test, tompa@clarus.se
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ class Bench
|
|||
Pmwx _pm;
|
||||
Point_location _pl(_pm);
|
||||
|
||||
std::cout << "Construction complited"<<std::endl;
|
||||
std::cout << "Construction completed"<<std::endl;
|
||||
try{
|
||||
this->start();
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
It's not finished reader off .bff it uses extended version of
|
||||
parser. I hope it will be useful for yours future works. By using
|
||||
this source you can easyly create yours own.
|
||||
this source you can easily create yours own.
|
||||
|
||||
missing
|
||||
Circular-arc
|
||||
|
|
|
|||
|
|
@ -212,7 +212,7 @@ class Bench
|
|||
Pmwx _pm;
|
||||
Point_location _pl(_pm);
|
||||
|
||||
std::cout << "Construction complited"<<std::endl;
|
||||
std::cout << "Construction completed"<<std::endl;
|
||||
try{
|
||||
this->start();
|
||||
for (typename ArcContainer::const_iterator it=ac.begin();
|
||||
|
|
|
|||
|
|
@ -1453,7 +1453,7 @@ template < class CK, class OutputIterator >
|
|||
// returns extra information, descriptive of the position of the returned
|
||||
// xy-monotone arcs on the circle: The output iterator refers to pairs, the
|
||||
// first part of which is the object containing the arc and the second part
|
||||
// is another pair containing 2 booleans which equavalently describe whether the
|
||||
// is another pair containing 2 booleans which equivalently describe whether the
|
||||
// returned xy-monotone arc is on the upper part and the left side of the circle
|
||||
|
||||
template < typename CK , typename Output_iterator>
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ int main() {
|
|||
CGAL::Random theRandom(random_seed);
|
||||
int count = 0;
|
||||
|
||||
std::cout << "We will compute the approximate probability that 3 spheres wit"
|
||||
<< "h radius 1 intersect on a 5x5x5 box, it might take some time." << std::endl;
|
||||
std::cout << "We will compute the approximate probability that 3 spheres with"
|
||||
<< " radius 1 intersect on a 5x5x5 box, it might take some time." << std::endl;
|
||||
|
||||
for(int i=0; i<10000; i++) {
|
||||
|
||||
|
|
|
|||
|
|
@ -470,7 +470,7 @@ int main (int argc, char** argv)
|
|||
}
|
||||
}
|
||||
|
||||
// Fill all holes except the bigest (which is the outer hull of the mesh)
|
||||
// Fill all holes except the biggest (which is the outer hull of the mesh)
|
||||
for (Mesh::Halfedge_index hi : holes)
|
||||
if (hi != outer_hull)
|
||||
CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ public:
|
|||
: less (comp), vless (vcomp), root (nullptr), m_min (nullptr),
|
||||
m_max (nullptr), _size (0)
|
||||
{
|
||||
// buids the tree
|
||||
// builds the tree
|
||||
/* Note: a more efficient algorithm building the tree bottom up may be
|
||||
worth implementing later */
|
||||
for (; first != last; ++first)
|
||||
|
|
|
|||
|
|
@ -352,7 +352,7 @@ void print_statistics() ;
|
|||
|
||||
/*!
|
||||
checks the
|
||||
validity of the data structure. If `throw_exceptions == thrue`
|
||||
validity of the data structure. If `throw_exceptions == true`
|
||||
then the program throws the following exceptions to inform about the
|
||||
problem.
|
||||
`chull_has_center_on_wrong_side_of_hull_facet` the
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ shared with other `My_geo_object` objects.
|
|||
|
||||
\section Developer_manualTemplatedhandles Templated handles
|
||||
|
||||
Factoring out the common functionality in base classes enables re-use of
|
||||
Factoring out the common functionality in base classes enables reuse of
|
||||
the code, but there is also a major drawback. The `Handle` class does not
|
||||
know the type of the representation object. It maintains a `Rep*` pointer.
|
||||
Therefore, this pointer must be cast to a pointer to the actual type
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ the same object with opposite orientation.
|
|||
|
||||
For a number of predicates, there are versions that operate on
|
||||
the coordinates directly, not on the geometric objects. These
|
||||
number-type based predicates ease re-use with non-<em>CGAL</em> types.
|
||||
number-type based predicates ease reuse with non-<em>CGAL</em> types.
|
||||
|
||||
\section secNewKernelTraits Missing functionality
|
||||
|
||||
|
|
@ -103,7 +103,7 @@ with a different API, then one should really implement the
|
|||
functionality and the others call that one.
|
||||
|
||||
Whenever you need a predicate that is not present in the current kernel
|
||||
traits, you should first try to re-use the available predicates (you
|
||||
traits, you should first try to reuse the available predicates (you
|
||||
might rewrite the code or implement the new predicate using existing ones).
|
||||
If this is not feasible (especially for efficiency reasons), we have to
|
||||
decide on adding the new predicate to the kernel traits.
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ The following pages describe how to use \cgal on different environments:
|
|||
|
||||
- \subpage windows
|
||||
|
||||
- \subpage thirdparty gives information (supported versions, download links) of the required and optional third party libraries.
|
||||
- \subpage thirdparty gives information (supported versions, download links) of the required and optional third-party libraries.
|
||||
|
||||
- \subpage devman_create_and_use_a_cmakelist explains how to use CMake to link a program with \cgal.
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ namespace CGAL {
|
|||
* two triangles, onto the \f$ xy\f$-plane, we obtain line segments. Indeed,
|
||||
* `Env_triangle_traits_3` inherits from the traits class that substitutes
|
||||
* `ArrSegmentTraits`, and extends it by adding operations on 3D objects, namely
|
||||
* spacial triangles. Note that the traits class does <I>not</I> define
|
||||
* spatial triangles. Note that the traits class does <I>not</I> define
|
||||
* `Kernel::Triangle_3` as its surface (and \f$ xy\f$-monotone surface) type, as
|
||||
* one may expect. This is because the traits class needs to store extra data
|
||||
* with the triangles in order to efficiently operate on them. Nevertheless,
|
||||
|
|
|
|||
|
|
@ -97,9 +97,9 @@ of planar arrangements, the `EnvelopeTraits_3` refines the
|
|||
concept must define the planar types `Point_2` and
|
||||
`X_monotone_curve_2` and support basic operations on them, as
|
||||
listed in Section \ref aos_sec-geom_traits. Moreover, it must define the
|
||||
spacial types `Surface_3` and `Xy_monotone_surface_3` (in practice,
|
||||
spatial types `Surface_3` and `Xy_monotone_surface_3` (in practice,
|
||||
these two types may be the same). Any model of the envelope-traits
|
||||
concept must also support the following operations on these spacial
|
||||
concept must also support the following operations on these spatial
|
||||
types:
|
||||
|
||||
\cgalFigureAnchor{env3_figcomp_over}
|
||||
|
|
|
|||
|
|
@ -2067,7 +2067,7 @@ protected:
|
|||
v2_is_new = true;
|
||||
}
|
||||
|
||||
// now use the approppriate method to insert the new edge
|
||||
// now use the appropriate method to insert the new edge
|
||||
if (v1_is_new && v2_is_new) {
|
||||
// if both vertices are new - use the O(1) operation
|
||||
// _insert_in_face_interior (in the face mapped to by he->face())
|
||||
|
|
|
|||
|
|
@ -311,7 +311,7 @@ protected:
|
|||
Halfedge_handle hh = vc;
|
||||
// update the map
|
||||
traversed_vertices[Vertex_face_pair(v, hh->face())] = hh;
|
||||
// check for reult
|
||||
// check for result
|
||||
if (hh->face() == f) result = hh;
|
||||
} while (++vc != vc_begin);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ class Filtered_Point_2
|
|||
#endif
|
||||
};
|
||||
|
||||
// For filtered constructions, we should be able to re-use the same predicates,
|
||||
// For filtered constructions, we should be able to reuse the same predicates,
|
||||
// but have different constructions and objects Point_2...
|
||||
template <class EK, class IK = Cartesian<Interval> >
|
||||
class Filtered_kernel
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@
|
|||
// - others ?
|
||||
// - benchmark on more algorithms.
|
||||
// - improve fit_in_double() for other NTs (MP_Float, Lazy). cf tools.h.
|
||||
// - try to automatize : have a struct a la Static_filter_error, with one part
|
||||
// - try to automate : have a struct a la Static_filter_error, with one part
|
||||
// which is runtime, and the other which can be constant-propagated by the
|
||||
// compiler. g++ 4.0 should be able to cprop the second part...
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ ball_d.cpp
|
|||
generates random points within an hyper ball in dim d.
|
||||
|
||||
cube_d.cpp
|
||||
generates random points wthin an hyper cube in dim d.
|
||||
generates random points within an hyper cube in dim d.
|
||||
|
||||
grid_d.cpp
|
||||
generates points on a grid in dim d.
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ public:
|
|||
|
||||
if (l.is_vertical()) {
|
||||
// Could be a tie.
|
||||
// To be "above" the curve, we acutually need to have smaller x coordinate,
|
||||
// To be "above" the curve, we actually need to have smaller x coordinate,
|
||||
// the order of the comparison function here is opposite to the none vertical
|
||||
// case.
|
||||
side = CGAL::opposite(side);
|
||||
|
|
|
|||
|
|
@ -155,7 +155,7 @@ since the latter automatically updates these values when it is resized (hence
|
|||
overwriting your values).
|
||||
|
||||
Non-positive dimension are silently replaced by a 1 pixel value to ensure
|
||||
frustrum coherence.
|
||||
frustum coherence.
|
||||
|
||||
If your Camera is used without a CGAL::QGLViewer (offscreen rendering, shadow maps),
|
||||
use setAspectRatio() instead to define the projection matrix. */
|
||||
|
|
|
|||
|
|
@ -189,7 +189,7 @@ namespace HomogeneousKernelFunctors {
|
|||
// want to solve alpha*v1 + beta*v2 + gamma*v3 == vp
|
||||
// let vi' == vi*vi.hw()
|
||||
// we solve alpha'*v1' + beta'*v2' + gamma'*v3' == vp' / vp.hw()
|
||||
// muliplied by vp.hw()
|
||||
// multiplied by vp.hw()
|
||||
// then we have alpha = alpha'*v1.hw() / vp.hw()
|
||||
// and beta = beta' *v2.hw() / vp.hw()
|
||||
// and gamma = gamma'*v3.hw() / vp.hw()
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ understand why
|
|||
|
||||
remove variant for supporting circle or line of bisector
|
||||
call it only when we know that it is a circle
|
||||
it will simplyfy the code of Construct_hyperbolic_bisector_2 at least in some cases
|
||||
it will simplify the code of Construct_hyperbolic_bisector_2 at least in some cases
|
||||
|
||||
test bisectors dual functions in special cases of euclidean line segments
|
||||
|
||||
|
|
|
|||
|
|
@ -4933,7 +4933,7 @@ CGAL now works around the preprocessor macros 'min' and 'max' defined in
|
|||
allows users to extend the DCEL of the underlying arrangement.
|
||||
- Added a function template called connect\_holes() that connects
|
||||
the holes in a given polygon with holes, turning it into a
|
||||
sequence of points, where the holes are connceted to the outer
|
||||
sequence of points, where the holes are connected to the outer
|
||||
boundary using zero-width passages.
|
||||
- Added a non-const function member to General\_polygon\_set\_2
|
||||
that obtains the underlying arrangement.
|
||||
|
|
|
|||
|
|
@ -139,10 +139,10 @@ macro(SuiteSparse_FIND_COMPONENTS )
|
|||
## special check for suitesparse component (allow to find on windows but not on linux because doesn't exist)
|
||||
list(FIND SuiteSparse_FIND_COMPONENTS "suitesparse" ss_index)
|
||||
if(${ss_index} MATCHES "-1")
|
||||
## do nothing, the user didn't provide the suisparse componnent
|
||||
## do nothing, the user didn't provide the suisparse component
|
||||
else()
|
||||
if(WIN32)
|
||||
## do nothing, the user provide the suisparse componnent we will try to find
|
||||
## do nothing, the user provide the suisparse component we will try to find
|
||||
else()
|
||||
list(REMOVE_AT SuiteSparse_FIND_COMPONENTS ${ss_index})
|
||||
if(SuiteSparse_VERBOSE)
|
||||
|
|
|
|||
|
|
@ -214,6 +214,6 @@ if ( NOT "${CGAL_CMAKE_EXACT_NT_BACKEND}" STREQUAL "Default" )
|
|||
TARGET CGAL
|
||||
APPEND PROPERTY
|
||||
INTERFACE_COMPILE_DEFINITIONS "CMAKE_OVERRIDDEN_DEFAULT_ENT_BACKEND=${DEB_VAL}"
|
||||
) # do not use set_target_properties to avoid overwritting
|
||||
) # do not use set_target_properties to avoid overwriting
|
||||
endif()
|
||||
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ struct Point_on_triangle
|
|||
}
|
||||
};
|
||||
|
||||
// the intersection of two triangles is computed by interatively intersection t2
|
||||
// the intersection of two triangles is computed by iteratively intersection t2
|
||||
// with halfspaces defined by edges of t1. The following function is called
|
||||
// for each each on t1 on edge of the current intersection.
|
||||
// pq is such an edge and p1q1 from t1 defines the halfspace intersection
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ Bounded_side bounded_side(const Point_3<Kernel> &p) const;
|
|||
|
||||
/// @}
|
||||
|
||||
/// \name Convencience Boolean Functions
|
||||
/// \name Convenience Boolean Functions
|
||||
/// @{
|
||||
|
||||
/*!
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ namespace KSR {
|
|||
|
||||
std::cout <<
|
||||
"parameter name: -silent" << std::endl <<
|
||||
"description: supress any intermediate output except for the final result" << std::endl << std::endl;
|
||||
"description: suppress any intermediate output except for the final result" << std::endl << std::endl;
|
||||
|
||||
std::cout <<
|
||||
"parameter name: -params" << std::endl <<
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
Kinetic Shape Partition
|
||||
|
||||
This CGAL package provides a way to partition 2D or 3D space by propagating
|
||||
2D segments or 3D polygons until they interesect the predefined number of times.
|
||||
2D segments or 3D polygons until they intersect the predefined number of times.
|
||||
|
|
|
|||
|
|
@ -2,5 +2,5 @@ Kinetic Shape Partition
|
|||
|
||||
This CGAL package provides a way to partition 2D or 3D space by propagating
|
||||
2D segments or 3D polygons until they intersect the predefined number of times.
|
||||
Once the partion is found, a 3D shape can be reconstructed by utilizing a graph cut approach.
|
||||
Once the partition is found, a 3D shape can be reconstructed by utilizing a graph cut approach.
|
||||
The final result is a piece-wise linear approximation of the given smooth shape.
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ The reconstruction is posed as an energy minimization labeling the convex volume
|
|||
</table>
|
||||
</center>
|
||||
|
||||
The labels \f$l \in {\{0, 1\}}^n\f$ denote the label for the \f$n\f$ volumes of the kinetic space partition. The data term measures the coherence of the labeled volumes with the orientation of normals of the input points. The prefered label for a volume is determined by a voting of the input points and their associated normals.
|
||||
The labels \f$l \in {\{0, 1\}}^n\f$ denote the label for the \f$n\f$ volumes of the kinetic space partition. The data term measures the coherence of the labeled volumes with the orientation of normals of the input points. The preferred label for a volume is determined by a voting of the input points and their associated normals.
|
||||
For each volume \f$i \in C\f$ the inliers from the shape detection associated with the faces of the volume \f$I_i\f$ either vote inside or outside for the volume. The vote is inside \f$d_i(p, inside) = 1\f$ and \f$d_i(p, outside = 0)\f$ if the normal associated to the point is directed to the outwards of the volume or outside \f$d_i(p, inside) = 0\f$ and \f$d_i(p, outside = 1)\f$ if the normal is oriented inwards.
|
||||
The regularization term is penalizing the total surface area of the surface and thus favoring less complex surfaces. To put the data term and regularization term into balance, area of each face is normalized by the total area of all faces \f$A\f$ and scaled by twice the total number of inliners \f$I\f$ from the shape detection as each inlier counts as one *inside* and one *outside* vote.
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ The reconstruction adds two new parameters:
|
|||
The min-cut formulation embeds a vertex into each volume and connects all vertices if the corresponding volumes share a common face. While each face inside the kinetic space partition is exactly between two volumes, faces on the boundary do not. Thus, 6 external vertices are inserted into the graph representing a volume on each side of the bounding box. The parameter *external_nodes* allows the user to either provide a fixed label *inside* or *outside* for each node or leave the label up to the energy minimization. Typical choices for this parameter are to choose all external nodes as outside for scanned objects, e.g., as in \cgalFigureRef{Ksr_pipelinefig}, or the *ZMIN* node *inside* and all other nodes *outside* as for exterior scans of buildings, e.g., as in \cgalFigureRef{Ksr_parametersfig}. The default value for this parameter is to leave the labels of the external nodes up to the energy minimization. The alternative method `reconstruct_with_ground` estimates a ground plane within the detected shapes and sets up all faces on the bounding box below that ground plane to be connected to an external node set as *inside* while all other faces on the outside are connected to external nodes set to *outside*. It assumes the z-axis to be the upward pointing vertical direction.
|
||||
|
||||
- *lambda*:
|
||||
The *lambda* parameter trades the data faithfulness of the energy minimization for low complexity. The parameter has to be choosen in the range of \f$[0,1)\f$. \f$0\f$ indicates maximal data faithfulness, while the default value of \f$0.5\f$ gives an equal weight to data faithfulness and low complexity. The value should be choosen according to the quality of the input data. If the point cloud is accurate, low in noise and complete a low value can be chosen.
|
||||
The *lambda* parameter trades the data faithfulness of the energy minimization for low complexity. The parameter has to be chosen in the range of \f$[0,1)\f$. \f$0\f$ indicates maximal data faithfulness, while the default value of \f$0.5\f$ gives an equal weight to data faithfulness and low complexity. The value should be chosen according to the quality of the input data. If the point cloud is accurate, low in noise and complete a low value can be chosen.
|
||||
|
||||
\section ksrParameterChoice Choice of Parameters
|
||||
The kinetic space partition determines all possible reconstructions as the energy formulation only decides about the labels for the volumes, but cannot change the volumes themselves. Thus, the first stages of the pipeline, \ref PkgShapeDetection "Shape Detection" and \ref PkgShapeRegularization "Shape Regularization", have a large impact on the final reconstruction. In the simple case of a cube, one missing side would depending on the chosen *lambda* parameter either make the cube expand on that side towards the bounding box or make the full cube disappear. A proper parameterization of the \ref PkgShapeDetection "Shape Detection" to detect all relevant shapes may have a large impact. The *debug* parameter allows to export intermediate results for inspection. This is especially helpful for larger scenes, where the time for the whole reconstruction requires more computational effort.
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ namespace KSR {
|
|||
|
||||
std::cout <<
|
||||
"parameter name: -silent" << std::endl <<
|
||||
"description: supress any intermediate output except for the final result" << std::endl << std::endl;
|
||||
"description: suppress any intermediate output except for the final result" << std::endl << std::endl;
|
||||
|
||||
std::cout <<
|
||||
"parameter name: -params" << std::endl <<
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ using Wrapper = CGAL::Alpha_wraps_3::internal::Alpha_wrapper_3<Oracle>;
|
|||
// - The visitor has a shared pointer to an emiter (can't emit directly from the visitor)
|
||||
// - The visitor has shared pointers to a polygon soup (+ colors), which it updates itself
|
||||
// before emitting a signal
|
||||
// - There is a pause in the emition because it needs to wait for the main thread to draw the
|
||||
// - There is a pause in the starting of the thread because it needs to wait for the main thread to draw the
|
||||
// polygon soup before the visitor updates the polygon soup.
|
||||
|
||||
struct Iterative_update_emiter
|
||||
|
|
|
|||
|
|
@ -643,7 +643,7 @@ public Q_SLOTS:
|
|||
QString filename;
|
||||
|
||||
int classifier = get_classifier();
|
||||
if (classifier == CGAL_CLASSIFICATION_SOWF_NUMBER) // Sum of Weighted Featuers
|
||||
if (classifier == CGAL_CLASSIFICATION_SOWF_NUMBER) // Sum of Weighted Features
|
||||
filename = QFileDialog::getSaveFileName(mw,
|
||||
tr("Save classification configuration"),
|
||||
tr("%1 (CGAL classif config).xml").arg(classif->item()->name()),
|
||||
|
|
@ -690,7 +690,7 @@ public Q_SLOTS:
|
|||
QString filename;
|
||||
|
||||
int classifier = get_classifier();
|
||||
if (classifier == CGAL_CLASSIFICATION_SOWF_NUMBER) // Sum of Weighted Featuers
|
||||
if (classifier == CGAL_CLASSIFICATION_SOWF_NUMBER) // Sum of Weighted Features
|
||||
filename = QFileDialog::getOpenFileName(mw,
|
||||
tr("Open CGAL classification configuration"),
|
||||
".",
|
||||
|
|
@ -1321,7 +1321,7 @@ public Q_SLOTS:
|
|||
QMultipleInputDialog dialog ("Train Classifier", mw);
|
||||
|
||||
int classifier = get_classifier();
|
||||
if (classifier == CGAL_CLASSIFICATION_SOWF_NUMBER) // Sum of Weighted Featuers
|
||||
if (classifier == CGAL_CLASSIFICATION_SOWF_NUMBER) // Sum of Weighted Features
|
||||
{
|
||||
QSpinBox* trials = dialog.add<QSpinBox> ("Number of trials: ", "trials");
|
||||
trials->setRange (1, 99999);
|
||||
|
|
|
|||
|
|
@ -279,7 +279,7 @@ private:
|
|||
QString name(z_tag) const { return tr("Z Slice for %2").arg(name_); }
|
||||
|
||||
//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 dimesion, to compensate it. So we don't want a max being the
|
||||
//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.
|
||||
//TODO: set the scale factors according to the dimensipon to avoid doing that.
|
||||
double compute_maxDim(x_tag) const
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
using namespace CGAL::Three;
|
||||
|
||||
// const std::size_t limit_fast_drawing = 300000; //arbitraty large value
|
||||
// const std::size_t limit_fast_drawing = 300000; //arbitrary large value
|
||||
|
||||
Scene_aff_transformed_point_set_item::
|
||||
Scene_aff_transformed_point_set_item(Scene_points_with_normal_item* pts_item,
|
||||
|
|
|
|||
|
|
@ -322,7 +322,7 @@ QString Scene_edit_box_item::toolTip() const {
|
|||
|
||||
QMenu* Scene_edit_box_item::contextMenu()
|
||||
{
|
||||
// diasable "Alpha slider" in menu
|
||||
// disable "Alpha slider" in menu
|
||||
QMenu* resMenu = Scene_item::contextMenu();
|
||||
bool prop = property("menu_changed").toBool();
|
||||
if(!prop)
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ public:
|
|||
//Contains the text and icons of an item in the Geometric Objects view
|
||||
QVariant data ( const QModelIndex & index,
|
||||
int role = ::Qt::DisplayRole ) const override;
|
||||
//@returns the type of data correspondind to the role.
|
||||
//@returns the type of data corresponding to the role.
|
||||
QVariant headerData ( int section, ::Qt::Orientation orientation,
|
||||
int role = ::Qt::DisplayRole ) const override;
|
||||
//@returns the flags for the item at the target index.
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Qt6)
|
|||
# ADD_DEFINITIONS("-pg")
|
||||
# set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg")
|
||||
|
||||
# To use valgrind, we must disable rounding math ckeck.
|
||||
# To use valgrind, we must disable rounding math check.
|
||||
# add_definitions(-DCGAL_DISABLE_ROUNDING_MATH_CHECK)
|
||||
|
||||
create_single_source_cgal_program("gmap_linear_cell_complex_3.cpp")
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ int main()
|
|||
ib.add_facet({5,4,7,6});
|
||||
|
||||
ib.begin_facet(); // Create a new facet version 2: begin facet
|
||||
ib.add_vertex_to_facet(0); // add sucessively its indices
|
||||
ib.add_vertex_to_facet(0); // add successively its indices
|
||||
ib.add_vertex_to_facet(3);
|
||||
ib.add_vertex_to_facet(4);
|
||||
ib.add_vertex_to_facet(5);
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ struct Tester2 {
|
|||
std::cerr << "Triangulation restored.\n";
|
||||
std::cerr << "Number of vertices: " << cdt.number_of_vertices() << "\n\n";
|
||||
|
||||
std::cerr << "2/ Comparaison between refine_Delaunay_mesh_2() and other"
|
||||
std::cerr << "2/ Comparison between refine_Delaunay_mesh_2() and other"
|
||||
<< " possibilities:\n\n";
|
||||
|
||||
std::cerr << "Meshing the triangulation with size 0.1, with "
|
||||
|
|
|
|||
|
|
@ -816,7 +816,7 @@ operator()(Visitor visitor)
|
|||
#endif
|
||||
|
||||
running_time_.stop();
|
||||
helper_.reset_cache();//in case we re-use caches in another operation
|
||||
helper_.reset_cache();//in case we reuse caches in another operation
|
||||
// after this perturbation
|
||||
|
||||
#ifdef CGAL_MESH_3_PERTURBER_VERBOSE
|
||||
|
|
|
|||
|
|
@ -1198,7 +1198,7 @@ expand_prestar(const Cell_handle& cell_to_add,
|
|||
|
||||
if(! tr_.is_infinite(current_mirror_cell))
|
||||
{
|
||||
// if current_mirror_cell is finite, we can re-use the value
|
||||
// if current_mirror_cell is finite, we can reuse the value
|
||||
// 'new_power_distance_to_power_sphere'
|
||||
|
||||
// Ensure that 'new_power_distance_to_power_sphere' has been initialized
|
||||
|
|
@ -1287,7 +1287,7 @@ get_best_weight(const Vertex_handle& v, bool *could_lock_zone) const
|
|||
&& pre_star.front()->first < (sq_delta_ * sq_d_v)
|
||||
&& ! c3t3_.is_in_complex(pre_star.front()->second) )
|
||||
{
|
||||
// Store critial radius (pre_star will be modified in expand_prestar)
|
||||
// Store critical radius (pre_star will be modified in expand_prestar)
|
||||
FT power_distance_to_power_sphere = pre_star.front()->first;
|
||||
|
||||
// expand prestar (insert opposite_cell facets in pre_star)
|
||||
|
|
|
|||
|
|
@ -611,7 +611,7 @@ edges of which are line segments and circular arcs of radius \f$ r\f$.
|
|||
|
||||
The inset can be computed using the convolution method traversing the
|
||||
polygon in a <I>clockwise</I> order (as oppose to the
|
||||
<I>counterclockwise</I> order applied in the case of ofsetting a polygon).
|
||||
<I>counterclockwise</I> order applied in the case of offsetting a polygon).
|
||||
As with the (outer) offset functions, the Minkowski-sum package contains two
|
||||
functions for insetting a simple polygon, namely,
|
||||
`approximated_inset_2(P, r, eps, oi)` and `inset_polygon_2(P, r, traits, oi)`.
|
||||
|
|
@ -647,7 +647,7 @@ The package also provides overloaded versions of the functions
|
|||
and
|
||||
\link offset_polygon_2() `offset_polygon_2(P, r, traits)`\endlink
|
||||
that accept a <I>polygon with holes</I>
|
||||
\f$ P\f$ and compute its offset. This ofset is obtain by computing the
|
||||
\f$ P\f$ and compute its offset. This offset is obtain by computing the
|
||||
outer offset of the outer boundary of \f$ P\f$'s, and computing the inner
|
||||
offsets of the holes of \f$ P\f$. The former polygon defines the output
|
||||
boundary of \f$ P \oplus B_r\f$, and the latter define the holes within
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ public:
|
|||
*m_p.holes_begin()->vertices_begin() + Vector_2(ORIGIN, t);
|
||||
|
||||
// Use bounded_side_2() instead of on_bounded_side() because the latter
|
||||
// checks vor simplicity every time.
|
||||
// checks for simplicity every time.
|
||||
bool in_mp(true);
|
||||
if (! m_p.outer_boundary().is_empty())
|
||||
in_mp =
|
||||
|
|
|
|||
|
|
@ -283,7 +283,7 @@ private:
|
|||
CGAL::decompose(arr, std::back_inserter(vd_list));
|
||||
|
||||
// Go over the vertices (given in ascending lexicographical xy-order),
|
||||
// and add segments to the feautres below and above it.
|
||||
// and add segments to the features below and above it.
|
||||
typename Vert_decomp_list::iterator it, prev = vd_list.end();
|
||||
for (it = vd_list.begin(); it != vd_list.end(); ++it) {
|
||||
// If the feature above the previous vertex is not the current vertex,
|
||||
|
|
|
|||
|
|
@ -1057,12 +1057,12 @@ public:
|
|||
typedef unspecified_type SHalfedge_around_facet_const_circulator;
|
||||
|
||||
/*!
|
||||
non-mutable iterator over the cylces of a sface.
|
||||
non-mutable iterator over the cycles of a sface.
|
||||
*/
|
||||
typedef unspecified_type SFace_cycle_const_iterator;
|
||||
|
||||
/*!
|
||||
non-mutable iterator over the cylces of a halffacet.
|
||||
non-mutable iterator over the cycles of a halffacet.
|
||||
*/
|
||||
typedef unspecified_type Halffacet_cycle_const_iterator;
|
||||
|
||||
|
|
|
|||
|
|
@ -369,7 +369,7 @@ public:
|
|||
continue;
|
||||
}
|
||||
|
||||
// We have to comapare the two scalar products sk0 and sk1. Therefore
|
||||
// We have to compare the two scalar products sk0 and sk1. Therefore
|
||||
// we have to normalize the input vectors vec0 and vec1, which means
|
||||
// that we have to divide them by their lengths len0 and len1.
|
||||
// To cicumvent irrational numbers, we square the whole inequality.
|
||||
|
|
|
|||
|
|
@ -325,14 +325,14 @@ supporting `s`.
|
|||
const Sphere_circle& sphere_circle() ;
|
||||
|
||||
/*!
|
||||
returns the sperical
|
||||
returns the spherical
|
||||
segment oriented from `target()` to `source()` with the same
|
||||
point set as `s`.
|
||||
*/
|
||||
Sphere_segment opposite() ;
|
||||
|
||||
/*!
|
||||
returns the sperical
|
||||
returns the spherical
|
||||
segment oriented from `target()` to `source()` with the
|
||||
point set completing `s` to a full circle.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -1020,7 +1020,7 @@ check_sphere(const Seg_list& L, bool compute_halfsphere[3][2]) const {
|
|||
// int l = it->compare_length_to_halfcircle();
|
||||
CGAL_NEF_TRACEN("source " << it->source());
|
||||
CGAL_NEF_TRACEN("target " << it->target());
|
||||
CGAL_NEF_TRACEN("cicle " << it->sphere_circle());
|
||||
CGAL_NEF_TRACEN("circle " << it->sphere_circle());
|
||||
CGAL_NEF_TRACEN("is long " << it->is_long());
|
||||
|
||||
if(it->is_short()) continue;
|
||||
|
|
|
|||
|
|
@ -150,13 +150,13 @@ const Sphere_circle<R>& sphere_circle() const { return this->ptr()->c_; }
|
|||
/*{\Mop the great circle supporting |\Mvar|.}*/
|
||||
|
||||
Sphere_segment<R> opposite() const
|
||||
/*{\Mop returns the sperical segment oriented from |target()|
|
||||
/*{\Mop returns the spherical segment oriented from |target()|
|
||||
to |source()| with the same point set as |\Mvar|. }*/
|
||||
{ return Sphere_segment<R>(
|
||||
target(),source(),sphere_circle().opposite()); }
|
||||
|
||||
Sphere_segment<R> complement() const
|
||||
/*{\Mop returns the sperical segment oriented from |target()|
|
||||
/*{\Mop returns the spherical segment oriented from |target()|
|
||||
to |source()| with the point set completing |\Mvar| to a
|
||||
full circle. }*/
|
||||
{ return Sphere_segment<R>(target(),source(),sphere_circle()); }
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ template <class T, class = void> struct pool3 {
|
|||
T data_ = 0;
|
||||
~cleaner(){
|
||||
// Deallocate everything. As an alternative, we could store it in a
|
||||
// global location, for re-use by a later thread.
|
||||
// global location, for reuse by a later thread.
|
||||
while (!empty())
|
||||
delete[] (pop() - (extra + 1));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ namespace Intern{
|
|||
* They are decomposable iff their coefficient type is.
|
||||
* The denominator \e d of an extension \e ext is a low common multiple
|
||||
* (see \c CGAL::Fraction_traits::Common_factor for details) of the
|
||||
* denominators of its coefficients. The numerator is the extenion
|
||||
* denominators of its coefficients. The numerator is the extension
|
||||
* \e d*ext with a fraction-free coefficient type.
|
||||
*
|
||||
* This works for nested Sqrt_extensions, too.
|
||||
|
|
|
|||
|
|
@ -550,7 +550,7 @@ void algebraic_real_test()
|
|||
}
|
||||
//simplify
|
||||
{
|
||||
// just a synatx check
|
||||
// just a syntax check
|
||||
ALGNUM(P_s2510,1,2).simplify();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ namespace CGAL {
|
|||
// This is a wrapper to convert a polyhedral surface to a periodic polyhedral domain
|
||||
// over a user-provided canonical domain.
|
||||
//
|
||||
// It is the user's responsability to ensure that the polyhedral domain is actually periodic
|
||||
// It is the user's responsibility to ensure that the polyhedral domain is actually periodic
|
||||
// over the canonical domain, i.e. there is periodic continuity at the boundaries
|
||||
// of the canonical domain.
|
||||
template<class TriangleMesh, class K>
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ insert_generic_dummy_points()
|
|||
return goff;
|
||||
};
|
||||
|
||||
// This should be prefered from building points from the lattice offset
|
||||
// This should be preferred from building points from the lattice offset
|
||||
// because the grid offset (by construction) aligns with the canonical domain,
|
||||
// and there is thus fewer numerical errors.
|
||||
auto construct_point_from_grid_offset = [&](const Offset& goff) -> Point_3
|
||||
|
|
|
|||
|
|
@ -202,7 +202,7 @@ OutputIterator range_search(Dt& delau,
|
|||
// Note that the function only works correctly with exact constructions
|
||||
// because it computes the circumcenter of the points a, b, and c
|
||||
// and then performs a range query with this circle.
|
||||
// When vertices of the trinagulation are on the circle the outcome
|
||||
// When vertices of the triangulation are on the circle the outcome
|
||||
// is not deterministic.
|
||||
// A solution would be to not construct a circle, but to use the
|
||||
// function CGAL::side_of_bounded_circle
|
||||
|
|
|
|||
|
|
@ -329,7 +329,7 @@ namespace CGAL {
|
|||
#ifdef CGAL_SURFACE_MESHER_DEBUG_CLIPPED_SEGMENT
|
||||
std::cerr << "=" << debug_point(surface, mid) << "\n";
|
||||
#endif
|
||||
// the following function conditionnally call
|
||||
// the following function conditionally call
|
||||
// mid.set_on_surface(...) if mid has such a function.
|
||||
set_on_surface(mid,
|
||||
surface_identifiers_generator(transform_functor(value_at_p1),
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
// `fast` takes an off file and an offset as arguments
|
||||
// If called additionally with 3 more vertex indices it performs the envelope test with the triangle
|
||||
// Otherwise it tests for all vertex triples forming a non-degenerate trianges
|
||||
// Otherwise it tests for all vertex triples forming a non-degenerate triangles
|
||||
// and writes the triple in the file inside.txt or outside.txt
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ typedef CGAL::Surface_mesh<K::Point_3> Mesh;
|
|||
|
||||
namespace PMP = CGAL::Polygon_mesh_processing;
|
||||
|
||||
// a sizing fied that is increasing the size of edge along the y-axis
|
||||
// a sizing field that is increasing the size of edge along the y-axis
|
||||
// starting at a minimum size at y-max and ending at a maximum size at
|
||||
// y-min, with a linear interpolation of sizes in between the two extreme
|
||||
// sizing values
|
||||
|
|
|
|||
|
|
@ -337,7 +337,7 @@ void angle_and_area_smoothing(const FaceRange& faces,
|
|||
*
|
||||
* Optionally, the points are reprojected after each iteration.
|
||||
*
|
||||
* See the overload which takes a face range as additonal parameter for a comprehensive description
|
||||
* See the overload which takes a face range as additional parameter for a comprehensive description
|
||||
* of the parameters.
|
||||
*/
|
||||
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
|
||||
|
|
|
|||
|
|
@ -145,12 +145,12 @@ struct Identity_functor
|
|||
*
|
||||
* \cgalNamedParamsBegin
|
||||
* \cgalParamNBegin{vertex_point_map}
|
||||
* \cgalParamDescription{a property map associating points to the vertices of `ouput`}
|
||||
* \cgalParamDescription{a property map associating points to the vertices of `output`}
|
||||
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<OutputMesh>::%vertex_descriptor`
|
||||
* as key type and `%Point_3` as value type}
|
||||
* \cgalParamDefault{`boost::get(CGAL::vertex_point, output)`}
|
||||
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
|
||||
* should be available for the vertices of `ouput`.}
|
||||
* should be available for the vertices of `output`.}
|
||||
* \cgalParamNEnd
|
||||
* \cgalNamedParamsEnd
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -1278,7 +1278,7 @@ class Intersection_of_triangle_meshes
|
|||
it_seg13->second.get_segments(f1f3_segments);
|
||||
|
||||
/// TODO AUTOREF_TAG shall we ignore tangency points?
|
||||
/// with the current code, Node_id_set::size()==1 is ignored as we only drop semgents
|
||||
/// with the current code, Node_id_set::size()==1 is ignored as we only drop segments
|
||||
/// Actually it might be that it is not a tangency point if the third segment was considered!
|
||||
/// so not handling it is a bug
|
||||
|
||||
|
|
|
|||
|
|
@ -366,7 +366,7 @@ private:
|
|||
s_av(s_av)
|
||||
{ }
|
||||
|
||||
// next two functions are just for convencience, the only thing ceres cares about is the operator()
|
||||
// next two functions are just for convenience, the only thing ceres cares about is the operator()
|
||||
template <typename T>
|
||||
FT area(const T x, const T y, const T z) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1000,7 +1000,7 @@ private:
|
|||
*
|
||||
* computes the interpolated corrected curvatures across the mesh `pmesh`.
|
||||
* By providing mean, Gaussian and/or principal curvature and direction property maps as named parameters, the user
|
||||
* can choose which quantites to compute.
|
||||
* can choose which quantities to compute.
|
||||
*
|
||||
* \note This function depends on the \eigen 3.1 (or later) library.
|
||||
*
|
||||
|
|
@ -1090,7 +1090,7 @@ void interpolated_corrected_curvatures(const PolygonMesh& pmesh,
|
|||
* \ingroup PMP_corrected_curvatures_grp
|
||||
* computes the interpolated corrected curvatures at a vertex `v`.
|
||||
* By providing mean, Gaussian and/or principal curvature and direction property maps as named parameters, the user
|
||||
* can choose which quantites to compute.
|
||||
* can choose which quantities to compute.
|
||||
*
|
||||
* \note This function depends on the \eigen 3.1 (or later) library.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -696,7 +696,7 @@ bool decimate_impl(const TriangleMesh& tm,
|
|||
{
|
||||
if (csts.size() > 3 && do_not_triangulate_faces)
|
||||
{
|
||||
// TODO this is not optimal at all since we already have the set of contraints,
|
||||
// TODO this is not optimal at all since we already have the set of constraints,
|
||||
// we could work on the graph on constraint and recover only the orientation
|
||||
// of the edge. To be done if someone find it too slow.
|
||||
std::vector<halfedge_descriptor> hborders;
|
||||
|
|
|
|||
|
|
@ -1749,7 +1749,7 @@ private:
|
|||
if (tti != CUT_FACE){
|
||||
continue;
|
||||
}
|
||||
// now we know that there exists an intesection point
|
||||
// now we know that there exists an intersection point
|
||||
|
||||
std::optional<ePoint_3> op = intersection_point_for_polyhedral_envelope(eline,
|
||||
halfspace[filtered_intersection[queue[i]]][intersect_face[queue[i]][j]].eplane);
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ void test_polygon_soup(std::string fname, bool expected)
|
|||
{
|
||||
Polyhedron p;
|
||||
|
||||
// just to test the named paramers
|
||||
// just to test the named parameters
|
||||
typedef std::pair<Point, bool> Point_with_Boolean;
|
||||
std::vector<Point_with_Boolean> points_with_pairs;
|
||||
for(const Point& pt : points)
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ struct Intersect_facets {
|
|||
if ( v != Halfedge_const_handle()) {
|
||||
// found shared vertex:
|
||||
assert( h->vertex() == v->vertex());
|
||||
// geomtric check if the opposite segments intersect the triangles
|
||||
// geometric check if the opposite segments intersect the triangles
|
||||
Triangle t1( h->vertex()->point(),
|
||||
h->next()->vertex()->point(),
|
||||
h->next()->next()->vertex()->point());
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ protected:
|
|||
bool first_vertex;
|
||||
bool last_vertex;
|
||||
|
||||
CGAL_assertion_code( int check_protocoll;) // use to check protocoll.
|
||||
CGAL_assertion_code( int check_protocoll;) // use to check_protocoll.
|
||||
// states for checking: 0 = created, 1 = constructing, 2 = make face.
|
||||
|
||||
// Implement the vertex_to_edge_map either with an array or
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ Polynomial<NT> modular_gcd_utcf_algorithm_M(
|
|||
#endif
|
||||
typedef Polynomial<NT> Poly;
|
||||
|
||||
// will paly the role of content
|
||||
// will play the role of content
|
||||
typedef typename CGAL::Scalar_factor_traits<Poly>::Scalar Scalar;
|
||||
|
||||
typedef typename CGAL::Modular_traits<Poly>::Residue_type MPoly;
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ Polynomial<NT> gcd_utcf_Integral_domain( Polynomial<NT> p1, Polynomial<NT> p2){
|
|||
|
||||
Polynomial<NT> q, r;
|
||||
|
||||
// TODO measure performance of both methodes with respect to
|
||||
// TODO measure performance of both methods with respect to
|
||||
// univariat polynomials on Integeres
|
||||
// univariat polynomials on Sqrt_extension<Integer,Integer>
|
||||
// multivariat polynomials
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ namespace CGAL {
|
|||
* This is an implementation of Ducos' algorithm. It improves on the
|
||||
* classical methods for subresultant computation by reducing the
|
||||
* swell-up of intermediate results. For all details, see
|
||||
* L.Ducos: Optimazations of the Subresultant algorithm. <i>Journal of Pure
|
||||
* L.Ducos: Optimizations of the Subresultant algorithm. <i>Journal of Pure
|
||||
* and Applied Algebra</i> <b>145</b> (2000) 149--163
|
||||
*/
|
||||
template <typename Polynomial_traits_d,typename OutputIterator> inline
|
||||
|
|
|
|||
|
|
@ -999,7 +999,7 @@ public:
|
|||
|
||||
// Sign_at, Sign_at_homogeneous, Compare
|
||||
// define XXX_ even though ICoeff may not be Real_embeddable
|
||||
// select propoer XXX among XXX_ or Null_functor using ::std::conditional_t
|
||||
// select proper XXX among XXX_ or Null_functor using ::std::conditional_t
|
||||
private:
|
||||
struct Sign_at_ {
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -704,7 +704,7 @@ class Width_3 {
|
|||
RT maxdist=0;
|
||||
RT hompart=1;
|
||||
//Try every point to be an/the antipodal vertex of the facet f. Take the
|
||||
//one with the bigest distance from E1
|
||||
//one with the biggest distance from E1
|
||||
DEBUGENDL(INITIAL_VF_PAIR,"Plane E1:",f->plane());
|
||||
while (vtxit != P.vertices_end() ) {
|
||||
RT pix, piy, piz, pih;
|
||||
|
|
@ -871,7 +871,7 @@ class Width_3 {
|
|||
<<"ASSERTION OK.");
|
||||
if ( a*nx+b*ny+c*nz+d*nh >= 0 ) {
|
||||
//Could be a violation. Now check if v and n lie on the
|
||||
//same plane. If so no violation, othervise we can break
|
||||
//same plane. If so no violation, otherwise we can break
|
||||
if (a*nx+b*ny+c*nz+d*nh == 0 ) {
|
||||
DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"Additional Antipodal Vertex "
|
||||
<<"found. Expanding "<<"set of witnesses.");
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ namespace CGAL {
|
|||
|
||||
\section Property_mapA A Short Introduction to the Boost Property Maps Library
|
||||
|
||||
The Boost Property Map Library consists mainly of interface specifications in the form of concepts. These interface specifications are intended for use by implementors of generic libraries in communicating requirements on template parameters to their users. In particular, the Boost Property Map concepts define a general purpose interface for mapping key objects to corresponding value objects, thereby hiding the details of how the mapping is implemented from algorithms. The implementation of types fulfilling the property map interface is up to the client of the algorithm to provide.
|
||||
The Boost Property Map Library consists mainly of interface specifications in the form of concepts. These interface specifications are intended for use by implementers of generic libraries in communicating requirements on template parameters to their users. In particular, the Boost Property Map concepts define a general purpose interface for mapping key objects to corresponding value objects, thereby hiding the details of how the mapping is implemented from algorithms. The implementation of types fulfilling the property map interface is up to the client of the algorithm to provide.
|
||||
|
||||
The Boost Property Map Library also contains a few adaptors that convert commonly used data-structures that implement a mapping operation, such as builtin arrays (pointers), iterators, and std::map, to have the property map interface.
|
||||
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ public:
|
|||
CGAL_precondition(m_active_indices.size() == m_data.size());
|
||||
}
|
||||
|
||||
// deactived as MSVC 2017 as an issue with that but it is not currently used.
|
||||
// deactivated as MSVC 2017 has an issue with that but it is not currently used.
|
||||
#if 0
|
||||
virtual void move(Property_array_base<Index>&& other_base) override {
|
||||
auto&& other = static_cast<Property_array<Index, T>&&>(other_base);
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ void test_property_creation() {
|
|||
static_assert(std::is_same_v<decltype(floats), std::reference_wrapper<Property_array<std::size_t, float>>>);
|
||||
assert(properties.num_properties() == 2);
|
||||
|
||||
// get() should retreive the same arrays
|
||||
// get() should retrieve the same arrays
|
||||
assert(integers.get() == properties.get_property<int>("integer"));
|
||||
assert(floats.get() == properties.get_property<float>("float"));
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ namespace QP_functions_detail {
|
|||
// p is treated as LinearProgram / QuadraticProgram
|
||||
// Is_nonnegative == Tag_true / Tag_false
|
||||
// p is treated as Nonnegative / Arbitrary
|
||||
// the dmatrix parameter specificies whether the quadratic matrix (if any)
|
||||
// the dmatrix parameter specifies whether the quadratic matrix (if any)
|
||||
// is written in DMATRIX format (no multiplication by two, good for
|
||||
// cross-checking output, or in QMATRIX format (good for using other
|
||||
// solvers like CPLEX)
|
||||
|
|
@ -83,7 +83,7 @@ namespace QP_functions_detail {
|
|||
bool is_in_equational_form (const R& r);
|
||||
|
||||
// internal routine:
|
||||
// test whether the row vectors of A that correpsond to equations
|
||||
// test whether the row vectors of A that correspond to equations
|
||||
// are linearly independent; this is done using type ET. The value
|
||||
// type of LinearInequalitySystem must be convertible to ET
|
||||
template <class Ar, class ET>
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ namespace QP_functions_detail {
|
|||
return true;
|
||||
}
|
||||
|
||||
// test whether the row vectors of A that correpsond to equations
|
||||
// test whether the row vectors of A that correspond to equations
|
||||
// are linearly independent; this is done using type ET. The value
|
||||
// type of LinearInequalitySystem must be convertible to ET
|
||||
template <class Ar, class ET>
|
||||
|
|
|
|||
|
|
@ -1053,7 +1053,7 @@ ratio_test_2( Tag_false)
|
|||
// optimal BEFORE a variable drops to zero. As delta = mu_j - mu_j(t_1),
|
||||
// the latter is precisely the case if delta_min >= -mu_j(t_1).
|
||||
//
|
||||
// (Note: please forget the crap identitiy between (2.11) and (2.12); the
|
||||
// (Note: please forget the crap identity between (2.11) and (2.12); the
|
||||
// notation is misleading.)
|
||||
//
|
||||
// Now to the nonstandard-form case.
|
||||
|
|
|
|||
|
|
@ -597,7 +597,7 @@ public:
|
|||
typedef Reference_counted_hierarchy_with_union<Alloc> Type;
|
||||
};
|
||||
|
||||
// abbreviation to re-use its implementation below.
|
||||
// abbreviation to reuse its implementation below.
|
||||
typedef Handle_policy_union U;
|
||||
|
||||
/*! \brief unifies the representations of the two handles \a h and \a g.
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ namespace CGAL { namespace internal {
|
|||
namespace boost_ {
|
||||
|
||||
/*
|
||||
* Note: array_binary_tree is a completey balanced binary tree.
|
||||
* Note: array_binary_tree is a completely balanced binary tree.
|
||||
*/
|
||||
#if !defined BOOST_NO_STD_ITERATOR_TRAITS
|
||||
template <class RandomAccessIterator, class ID>
|
||||
|
|
|
|||
|
|
@ -263,7 +263,7 @@ lexicographical_compare_three_valued( InputIterator1 first1, InputIterator1 last
|
|||
The iterator range \c [first,beyond) is written
|
||||
to \c os (obeying CGAL I/O modes). Each element is bracketed by
|
||||
\c pre and \c post (default: empty string). Adjacent values are
|
||||
spearated by \c sep (default: ", ", i.e. comma space).
|
||||
separated by \c sep (default: ", ", i.e. comma space).
|
||||
The stream \c os is returned in its new state after output.
|
||||
|
||||
Example:
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ private:
|
|||
// The shape must be a pointer, because the alpha of a Fixed_alpha_shape_3
|
||||
// can only be set at construction and its assignment operator is private.
|
||||
// We want to be able to set the alpha after constructing the scale-space
|
||||
// reconstructer object.
|
||||
// reconstructor object.
|
||||
Shape* _shape;
|
||||
|
||||
// The surface. If the surface is collected per shell, the triples of the
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
# * or alternatively curl
|
||||
#
|
||||
# Furthermore you have to edit .autocgalrc in order to
|
||||
# cutomize it for your environment.
|
||||
# customize it for your environment.
|
||||
# In particular you have to change the BUILHOSTS
|
||||
# variable to contain the names of your hosts and
|
||||
# set the COMPILERS_<hostname> variables to the
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#include <vector>
|
||||
|
||||
#define SDG_DRAW_DEBUG // debug log
|
||||
#define SDG_DRAW_DUMP_FILES // print input / ouput
|
||||
#define SDG_DRAW_DUMP_FILES // print input / output
|
||||
// #define SINGLE_INPUT_FILE // if not defined, each segment of the input has its own file
|
||||
|
||||
#ifdef SDG_DRAW_DUMP_FILES_PP // also print parabolas
|
||||
|
|
|
|||
|
|
@ -2549,7 +2549,7 @@ arrangement_type(const Site_2& p, const Site_2& q) const
|
|||
|
||||
Arrangement_type res = geom_traits().arrangement_type_2_object()(p, q);
|
||||
|
||||
// The valeus that have to be treated are the following:
|
||||
// The values that have to be treated are the following:
|
||||
// DISJOINT, TOUCH_1, TOUCH_2, CROSSING, IDENTICAL, INTERIOR,
|
||||
// TOUCH_11_INTERIOR_1, TOUCH_12_INTERIOR_1, TOUCH_21_INTERIOR_1 and
|
||||
// TOUCH_22_INTERIOR_1.
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ private:
|
|||
bool q_exact = q.is_input();
|
||||
bool t_exact = t.is_input();
|
||||
bool filtered = false;
|
||||
// the following if-statement does the gometric filtering...
|
||||
// the following if-statement does the geometric filtering...
|
||||
// maybe it is not so important since this will only be
|
||||
// activated if a lot of intersection points appear on the
|
||||
// convex hull
|
||||
|
|
@ -239,7 +239,7 @@ private:
|
|||
bool q_exact = q.is_input();
|
||||
bool t_exact = t.is_input();
|
||||
bool filtered = false;
|
||||
// the following if-statement does the gometric filtering...
|
||||
// the following if-statement does the geometric filtering...
|
||||
// maybe it is not so important since this will only be
|
||||
// activated if a lot of intersection points appear on the
|
||||
// convex hull
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ private:
|
|||
bool q_exact = q.is_input();
|
||||
bool t_exact = t.is_input();
|
||||
bool filtered = false;
|
||||
// the following if-statement does the gometric filtering...
|
||||
// the following if-statement does the geometric filtering...
|
||||
// maybe it is not so important since this will only be
|
||||
// activated if a lot of intersection points appear on the
|
||||
// convex hull
|
||||
|
|
@ -284,7 +284,7 @@ private:
|
|||
bool q_exact = q.is_input();
|
||||
bool t_exact = t.is_input();
|
||||
bool filtered = false;
|
||||
// the following if-statement does the gometric filtering...
|
||||
// the following if-statement does the geometric filtering...
|
||||
// maybe it is not so important since this will only be
|
||||
// activated if a lot of intersection points appear on the
|
||||
// convex hull
|
||||
|
|
|
|||
|
|
@ -308,7 +308,7 @@ namespace Polygon_mesh {
|
|||
// The best fit plane will be a plane fitted to all vertices of all
|
||||
// region faces with its normal being perpendicular to the plane.
|
||||
// Given that the points, and no normals, are used in estimating
|
||||
// the plane, the estimated normal will point into an arbitray
|
||||
// the plane, the estimated normal will point into an arbitrary
|
||||
// one of the two possible directions.
|
||||
// We flip it into the correct direction (the one that the majority
|
||||
// of faces agree with) below.
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue