Merge remote-tracking branch 'cgal/master' into Mesh_3-triple_line_extraction-GF
# Conflicts: # Mesh_3/test/Mesh_3/CMakeLists.txt
This commit is contained in:
@@ -1,5 +1,4 @@
|
||||
#!/bin/bash
|
||||
sudo add-apt-repository ppa:mikhailnov/pulseeffects -y
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y libmpfr-dev \
|
||||
libeigen3-dev qtbase5-dev libqt5sql5-sqlite libqt5opengl5-dev qtscript5-dev \
|
||||
|
||||
@@ -2,6 +2,7 @@ name: remove_labels
|
||||
on:
|
||||
pull_request_target:
|
||||
types: [synchronize]
|
||||
workflow_dispatch:
|
||||
jobs:
|
||||
remove_label:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
@@ -47,14 +47,6 @@ jobs:
|
||||
//get pullrequest url
|
||||
const pr_number = context.payload.issue.number
|
||||
return pr_number
|
||||
- uses: actions/checkout@v3
|
||||
name: "checkout branch"
|
||||
if: steps.get_round.outputs.result != 'stop'
|
||||
with:
|
||||
repository: ${{ github.repository }}
|
||||
ref: refs/pull/${{ steps.get_pr_number.outputs.result }}/merge
|
||||
token: ${{ secrets.PUSH_TO_CGAL_GITHUB_IO_TOKEN }}
|
||||
fetch-depth: 2
|
||||
|
||||
- name: Emoji-comment
|
||||
uses: actions/github-script@v6
|
||||
@@ -67,6 +59,15 @@ jobs:
|
||||
repo: context.repo.repo,
|
||||
content: 'rocket'
|
||||
})
|
||||
|
||||
- uses: actions/checkout@v3
|
||||
name: "checkout branch"
|
||||
if: steps.get_round.outputs.result != 'stop'
|
||||
with:
|
||||
repository: ${{ github.repository }}
|
||||
ref: refs/pull/${{ steps.get_pr_number.outputs.result }}/merge
|
||||
fetch-depth: 2
|
||||
|
||||
- name: install dependencies
|
||||
if: steps.get_round.outputs.result != 'stop'
|
||||
run: |
|
||||
@@ -151,11 +152,13 @@ jobs:
|
||||
});
|
||||
|
||||
- name: Post error
|
||||
env:
|
||||
ERRORMSG: ${{steps.build_and_run.outputs.DoxygenError}}
|
||||
uses: actions/github-script@v6
|
||||
if: ${{ failure() && steps.get_round.outputs.result != 'stop' }}
|
||||
with:
|
||||
script: |
|
||||
const error = "${{steps.build_and_run.outputs.DoxygenError}}"
|
||||
const error = process.env.ERRORMSG
|
||||
const msg = "There was an error while building the doc: \n"+error
|
||||
github.rest.issues.createComment({
|
||||
owner: "CGAL",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
name: CMake Test Merge Branch
|
||||
|
||||
on: [push, pull_request]
|
||||
on: [push, pull_request, workflow_dispatch]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
name: CMake Testsuite
|
||||
|
||||
on: [push, pull_request]
|
||||
on: [push, pull_request, workflow_dispatch]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
@@ -2,7 +2,7 @@ name: Documentation Removal
|
||||
|
||||
on:
|
||||
pull_request_target:
|
||||
types: [closed, removed]
|
||||
types: [closed, removed, workflow_dispatch]
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
name: Test Polyhedron Demo
|
||||
|
||||
on: [push, pull_request]
|
||||
on: [push, pull_request,workflow_dispatch]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
@@ -3,6 +3,7 @@ name: Filter Testsuite
|
||||
on:
|
||||
issue_comment:
|
||||
types: [created]
|
||||
workflow_dispatch:
|
||||
|
||||
permissions: {}
|
||||
jobs:
|
||||
|
||||
@@ -6,12 +6,14 @@ project(AABB_traits_benchmark)
|
||||
|
||||
find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Core)
|
||||
|
||||
# google benchmark
|
||||
find_package(benchmark)
|
||||
|
||||
if (benchmark_FOUND)
|
||||
create_single_source_cgal_program("tree_creation.cpp")
|
||||
target_link_libraries(tree_creation benchmark::benchmark)
|
||||
endif()
|
||||
create_single_source_cgal_program("test.cpp")
|
||||
create_single_source_cgal_program("tree_construction.cpp")
|
||||
|
||||
# google benchmark
|
||||
find_package(benchmark QUIET)
|
||||
if(benchmark_FOUND)
|
||||
create_single_source_cgal_program("tree_creation.cpp")
|
||||
target_link_libraries(tree_creation benchmark::benchmark)
|
||||
else()
|
||||
message(STATUS "NOTICE: The benchmark 'tree_creation.cpp' requires the Google benchmark library, and will not be compiled.")
|
||||
endif()
|
||||
|
||||
@@ -5,6 +5,7 @@ project(AABB_tree_Demo)
|
||||
|
||||
# Find includes in corresponding build directories
|
||||
set(CMAKE_INCLUDE_CURRENT_DIR ON)
|
||||
|
||||
# Instruct CMake to run moc automatically when needed.
|
||||
set(CMAKE_AUTOMOC ON)
|
||||
if(NOT POLICY CMP0070 AND POLICY CMP0053)
|
||||
@@ -31,10 +32,8 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
||||
include(AddFileDependencies)
|
||||
|
||||
qt5_generate_moc("MainWindow.h"
|
||||
"${CMAKE_CURRENT_BINARY_DIR}/MainWindow_moc.cpp")
|
||||
add_file_dependencies(MainWindow_moc.cpp
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/MainWindow.h")
|
||||
qt5_generate_moc("MainWindow.h" "${CMAKE_CURRENT_BINARY_DIR}/MainWindow_moc.cpp")
|
||||
add_file_dependencies(MainWindow_moc.cpp "${CMAKE_CURRENT_SOURCE_DIR}/MainWindow.h")
|
||||
|
||||
qt5_generate_moc("Viewer.h" "${CMAKE_CURRENT_BINARY_DIR}/Viewer_moc.cpp")
|
||||
add_file_dependencies(Viewer_moc.cpp "${CMAKE_CURRENT_SOURCE_DIR}/Viewer.h")
|
||||
@@ -62,8 +61,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
include(${CGAL_MODULES_DIR}/CGAL_add_test.cmake)
|
||||
cgal_add_compilation_test(AABB_demo)
|
||||
|
||||
else(CGAL_Qt5_FOUND
|
||||
AND Qt5_FOUND)
|
||||
else(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
||||
set(AABB_MISSING_DEPS "")
|
||||
|
||||
@@ -75,11 +73,6 @@ else(CGAL_Qt5_FOUND
|
||||
set(AABB_MISSING_DEPS "Qt5, ${AABB_MISSING_DEPS}")
|
||||
endif()
|
||||
|
||||
message(
|
||||
STATUS
|
||||
"NOTICE: This demo requires ${AABB_MISSING_DEPS}and will not be compiled."
|
||||
)
|
||||
message("NOTICE: This demo requires ${AABB_MISSING_DEPS}, and will not be compiled.")
|
||||
|
||||
endif(
|
||||
CGAL_Qt5_FOUND
|
||||
AND Qt5_FOUND)
|
||||
endif(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
||||
@@ -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++)
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
<body>
|
||||
<h2>AABB Tree Demo</h2>
|
||||
<p>Copyright ©2009
|
||||
<a href="http://www-sop.inria.fr/">INRIA Sophia Antipolis - Mediterranee<a/></p>
|
||||
<p>This application illustrates the AABB tree component
|
||||
<a href="https://www.inria.fr/fr/centre-inria-universite-cote-azur">INRIA Sophia Antipolis - Mediterranee<a/></p>
|
||||
<p>This application illustrates the AABB tree component
|
||||
of <a href="https://www.cgal.org/">CGAL</a>, applied to polyhedron
|
||||
facets and edges.</p>
|
||||
<p>See also the following chapters of the manual:
|
||||
|
||||
@@ -74,7 +74,7 @@ typedef unspecified_type Construct_projected_point_3;
|
||||
/*!
|
||||
A functor object to compare the distance of two points wrt a third one. Provides the operator:
|
||||
|
||||
`CGAL::Comparision_result operator()(const Point_3& p1, const Point_3& p2, const Point_3& p3)`,
|
||||
`CGAL::Comparison_result operator()(const Point_3& p1, const Point_3& p2, const Point_3& p3)`,
|
||||
|
||||
which compares the distance between `p1 and `p2`, and between `p2` and `p3`.
|
||||
*/
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
+77
-91
@@ -370,19 +370,19 @@ namespace CGAL {
|
||||
coord_type K, min_K;
|
||||
const coord_type eps;
|
||||
const coord_type inv_eps_2; // 1/(eps^2)
|
||||
const coord_type eps_3; // test de ^3 donc points tel 1e-7 soit petit
|
||||
const coord_type eps_3; // tests using cubed eps so points such that 1e-7 is small
|
||||
const criteria STANDBY_CANDIDATE;
|
||||
const criteria STANDBY_CANDIDATE_BIS;
|
||||
const criteria NOT_VALID_CANDIDATE;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
//Pour une visu correcte
|
||||
//pour retenir les facettes selectionnees
|
||||
// For a correct visualization
|
||||
// to retain the selected facets
|
||||
int _vh_number;
|
||||
int _facet_number;
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
//Pour le post traitement
|
||||
// For post-processing
|
||||
mutable int _postprocessing_counter;
|
||||
int _size_before_postprocessing;
|
||||
|
||||
@@ -501,9 +501,8 @@ namespace CGAL {
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
// pour gerer certaines aretes interieures: a savoir celle encore connectee au
|
||||
// bord (en fait seule, les aretes interieures reliant 2 bords nous
|
||||
// interressent...)
|
||||
// to handle certain interior edges, meaning those still connected to the boundary
|
||||
// (actually, only the interior edges linking two boundaries are relevant)
|
||||
|
||||
inline void set_interior_edge(Vertex_handle w, Vertex_handle v)
|
||||
{
|
||||
@@ -806,7 +805,7 @@ namespace CGAL {
|
||||
|
||||
if ((number_of_facets() > static_cast<int>(T.number_of_vertices()))&&
|
||||
(NB_BORDER_MAX > 0))
|
||||
// en principe 2*nb_sommets = nb_facettes: y a encore de la marge!!!
|
||||
// in theory 2*vertices_n = facets_n: plenty of room!!!
|
||||
{
|
||||
while(postprocessing()){
|
||||
extend2_timer.start();
|
||||
@@ -1068,9 +1067,8 @@ namespace CGAL {
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
bool is_interior_edge(const Edge_like& key) const
|
||||
// pour gerer certaines aretes interieures: a savoir celle encore connectee au
|
||||
// bord (en fait seule, les aretes interieures reliant 2 bords nous
|
||||
// interressent...)
|
||||
// to handle certain interior edges, meaning those still connected to the boundary
|
||||
// (actually, only the interior edges linking two boundaries are relevant)
|
||||
{
|
||||
return (is_interior_edge(key.first, key.second)||
|
||||
is_interior_edge(key.second, key.first));
|
||||
@@ -1299,7 +1297,6 @@ namespace CGAL {
|
||||
#ifdef AFSR_LAZY
|
||||
value = lazy_squared_radius(cc);
|
||||
#else
|
||||
// qualified with CGAL, to avoid a compilation error with clang
|
||||
if(volume(pp0, pp1, pp2, pp3) != 0){
|
||||
value = T.geom_traits().compute_squared_radius_3_object()(pp0, pp1, pp2, pp3);
|
||||
} else {
|
||||
@@ -1337,7 +1334,6 @@ namespace CGAL {
|
||||
{
|
||||
value = compute_scalar_product(Vc, Vc) - ac*ac/norm_V;
|
||||
if ((value < 0)||(norm_V > inv_eps_2)){
|
||||
// qualified with CGAL, to avoid a compilation error with clang
|
||||
value = T.geom_traits().compute_squared_radius_3_object()(cp1, cp2, cp3);
|
||||
}
|
||||
}
|
||||
@@ -1365,7 +1361,7 @@ namespace CGAL {
|
||||
/// @}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// For a border edge e we determine the incident facet which has the highest
|
||||
// For a border edge e, we determine the incident facet which has the highest
|
||||
// chance to be a natural extension of the surface
|
||||
|
||||
Radius_edge_type
|
||||
@@ -1425,8 +1421,7 @@ namespace CGAL {
|
||||
P2Pn = construct_vector(p2, pn);
|
||||
v2 = construct_cross_product(P2P1,P2Pn);
|
||||
|
||||
//pas necessaire de normer pour un bon echantillon:
|
||||
// on peut alors tester v1*v2 >= 0
|
||||
// no need to normalize for a correct sampling: one can then test v1*v2 >= 0
|
||||
norm = sqrt(norm1 * compute_scalar_product(v2,v2));
|
||||
pscal = v1*v2;
|
||||
// check if the triangle will produce a sliver on the surface
|
||||
@@ -1437,7 +1432,8 @@ namespace CGAL {
|
||||
if (tmp < min_valueA)
|
||||
{
|
||||
PnP1 = p1-pn;
|
||||
// DELTA represente la qualite d'echantillonnage du bord
|
||||
// DELTA encodes the quality of the border sampling
|
||||
//
|
||||
// We skip triangles having an internal angle along e
|
||||
// whose cosinus is smaller than -DELTA
|
||||
// that is the angle is larger than arcos(-DELTA)
|
||||
@@ -1462,37 +1458,36 @@ namespace CGAL {
|
||||
|
||||
if ((min_valueA == infinity()) || border_facet) // bad facets case
|
||||
{
|
||||
min_facet = Facet(c, i); // !!! sans aucune signification....
|
||||
value = NOT_VALID_CANDIDATE; // Attention a ne pas inserer dans PQ
|
||||
min_facet = Facet(c, i); // !!! without any meaning....
|
||||
value = NOT_VALID_CANDIDATE; // Do not insert in the PQ
|
||||
}
|
||||
else
|
||||
{
|
||||
min_facet = min_facetA;
|
||||
|
||||
//si on considere seulement la pliure value appartient a [0, 2]
|
||||
//value = coord_type(1) - min_valueP;
|
||||
|
||||
// si la pliure est bonne on note suivant le alpha sinon on prend en compte la
|
||||
// pliure seule... pour discriminer entre les bons slivers...
|
||||
// si on veut discriminer les facettes de bonnes pliures plus finement
|
||||
// alors -(1+1/min_valueA) app a [-inf, -1]
|
||||
// -min_valueP app a [-1, 1]
|
||||
// If we only consider the fold value belongs to [0, 2]
|
||||
// value = coord_type(1) - min_valueP;
|
||||
|
||||
// If the fold is OK, we rate based on the alpha value. Otherwise, take only the fold into account
|
||||
// to discriminate between good slivers.
|
||||
//
|
||||
// If we wish to discriminate the facets with good folds more finely,
|
||||
// then:
|
||||
// -(1+1/min_valueA) is within [-inf, -1]
|
||||
// -min_valueP is within [-1, 1]
|
||||
//
|
||||
if (min_valueP > COS_BETA)
|
||||
value = -(coord_type(1) + coord_type(1)/min_valueA);
|
||||
else
|
||||
{
|
||||
//on refuse une trop grande non-uniformite
|
||||
// reject overly non-uniform values
|
||||
coord_type tmp = priority (*this, c, i);
|
||||
if (min_valueA <= K * tmp)
|
||||
value = - min_valueP;
|
||||
else
|
||||
{
|
||||
value = STANDBY_CANDIDATE; // tres mauvais candidat mauvaise pliure
|
||||
// + grand alpha... a traiter plus tard....
|
||||
min_K =
|
||||
(std::min)(min_K,
|
||||
min_valueA/tmp);
|
||||
value = STANDBY_CANDIDATE; // extremely bad candidate, bad fold + large alpha; handle later
|
||||
min_K = (std::min)(min_K, min_valueA/tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1597,7 +1592,7 @@ namespace CGAL {
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// test de reciprocite avant de recoller une oreille anti-singularite
|
||||
// reciprocity test before glueing anti-singularity ear
|
||||
int
|
||||
test_merge(const Edge_like& ordered_key, const Border_elt& result,
|
||||
const Vertex_handle& v, const coord_type& ear_alpha)
|
||||
@@ -1622,12 +1617,12 @@ namespace CGAL {
|
||||
coord_type norm = sqrt(compute_scalar_product(v1, v1) * compute_scalar_product(v2, v2));
|
||||
|
||||
if (v1*v2 > COS_BETA*norm)
|
||||
return 1; // label bonne pliure sinon:
|
||||
return 1; // mark as good fold
|
||||
|
||||
if (ear_alpha <= K * priority(*this, neigh, n_ind))
|
||||
return 2; // label alpha coherent...
|
||||
return 2; // mark alpha consistent
|
||||
|
||||
return 0; //sinon oreille a rejeter...
|
||||
return 0; // ear to be rejected
|
||||
}
|
||||
|
||||
|
||||
@@ -1753,7 +1748,7 @@ namespace CGAL {
|
||||
Edge_like ordered_key(v1,v2);
|
||||
|
||||
if (!is_border_elt(ordered_key, result12))
|
||||
std::cerr << "+++probleme coherence bord <validate>" << std::endl;
|
||||
std::cerr << "+++issue with border consistency <validate>" << std::endl;
|
||||
|
||||
bool is_border_el1 = is_border_elt(ordered_el1, result1),
|
||||
is_border_el2 = is_border_elt(ordered_el2, result2);
|
||||
@@ -1782,8 +1777,7 @@ namespace CGAL {
|
||||
return FINAL_CASE;
|
||||
}
|
||||
//---------------------------------------------------------------------
|
||||
//on peut alors marquer v1 et on pourrait essayer de merger
|
||||
//sans faire de calcul inutile???
|
||||
// we can then mark v1 and could try to merge without any useless computation???
|
||||
if (is_border_el1)
|
||||
{
|
||||
Edge_incident_facet edge_Ifacet_2(Edge(c, i, edge_Efacet.first.third),
|
||||
@@ -1796,7 +1790,7 @@ namespace CGAL {
|
||||
return EAR_CASE;
|
||||
}
|
||||
//---------------------------------------------------------------------
|
||||
//idem pour v2
|
||||
//idem for v2
|
||||
if (is_border_el2)
|
||||
{
|
||||
Edge_incident_facet edge_Ifacet_1(Edge(c, i, edge_Efacet.first.second),
|
||||
@@ -1852,9 +1846,9 @@ namespace CGAL {
|
||||
// border incident to a point... _mark<1 even if th orientation
|
||||
// may be such as one vh has 2 successorson the same border...
|
||||
{
|
||||
// a ce niveau on peut tester si le recollement se fait en
|
||||
// maintenant la compatibilite d'orientation des bords (pour
|
||||
// surface orientable...) ou si elle est brisee...
|
||||
// at this level, we can test if glueing can be done while keeping
|
||||
// compatible orientations for the borders (for an orientable surface...)
|
||||
// or if it is broken
|
||||
Edge_incident_facet edge_Ifacet_1(Edge(c, i, edge_Efacet.first.second),
|
||||
edge_Efacet.second);
|
||||
Edge_incident_facet edge_Ifacet_2(Edge(c, i, edge_Efacet.first.third),
|
||||
@@ -1884,8 +1878,8 @@ namespace CGAL {
|
||||
Border_elt result_ear2;
|
||||
|
||||
Edge_like ear1_e, ear2_e;
|
||||
// pour maintenir la reconstruction d'une surface orientable :
|
||||
// on verifie que les bords se recollent dans des sens opposes
|
||||
// to preserve the reconstruction of an orientable surface, we check that
|
||||
// borders glue to one another in opposite directions
|
||||
if (ordered_key.first==v1)
|
||||
{
|
||||
ear1_e = Edge_like(c->vertex(i), ear1_c ->vertex(ear1_i));
|
||||
@@ -1897,7 +1891,7 @@ namespace CGAL {
|
||||
ear2_e = Edge_like(c->vertex(i), ear2_c ->vertex(ear2_i));
|
||||
}
|
||||
|
||||
//maintient la surface orientable
|
||||
// preserves orientability of the surface
|
||||
bool is_border_ear1 = is_ordered_border_elt(ear1_e, result_ear1);
|
||||
bool is_border_ear2 = is_ordered_border_elt(ear2_e, result_ear2);
|
||||
bool ear1_valid(false), ear2_valid(false);
|
||||
@@ -1931,8 +1925,7 @@ namespace CGAL {
|
||||
{
|
||||
Validation_case res = validate(ear1, e1.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing: case " << res << std::endl;
|
||||
e2 = compute_value(edge_Ifacet_2);
|
||||
|
||||
if (ordered_key.first == v1)
|
||||
@@ -1948,8 +1941,7 @@ namespace CGAL {
|
||||
{
|
||||
Validation_case res = validate(ear2, e2.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing : case " << res << std::endl;
|
||||
e1 = compute_value(edge_Ifacet_1);
|
||||
|
||||
if (ordered_key.first == v1)
|
||||
@@ -1962,25 +1954,23 @@ namespace CGAL {
|
||||
_ordered_border.insert(Radius_ptr_type(e1.first, p1));
|
||||
}
|
||||
}
|
||||
else// les deux oreilles ne se recollent pas sur la meme arete...
|
||||
else // both ears do not glue on the same edge
|
||||
{
|
||||
// on resoud la singularite.
|
||||
// resolve the singularity
|
||||
if (ear1_valid)
|
||||
{
|
||||
Validation_case res = validate(ear1, e1.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing: case " << res << std::endl;
|
||||
}
|
||||
if (ear2_valid)
|
||||
{
|
||||
Validation_case res = validate(ear2, e2.first);
|
||||
if (!((res == EAR_CASE)||(res == FINAL_CASE)))
|
||||
std::cerr << "+++probleme de recollement : cas "
|
||||
<< res << std::endl;
|
||||
std::cerr << "+++issue in glueing : case " << res << std::endl;
|
||||
}
|
||||
// on met a jour la PQ s'il y a lieu... mais surtout pas
|
||||
// avant la resolution de la singularite
|
||||
|
||||
// Update the PQ if needed, but not before resolving the singularity
|
||||
if (!ear1_valid)
|
||||
{
|
||||
_ordered_border.insert(Radius_ptr_type(e1.first, p1));
|
||||
@@ -2020,7 +2010,7 @@ namespace CGAL {
|
||||
|
||||
if (new_candidate.first == STANDBY_CANDIDATE)
|
||||
{
|
||||
// a garder pour un K un peu plus grand...
|
||||
// put aside for a slightly larger K
|
||||
new_candidate.first = STANDBY_CANDIDATE_BIS;
|
||||
}
|
||||
|
||||
@@ -2042,8 +2032,8 @@ namespace CGAL {
|
||||
void
|
||||
extend()
|
||||
{
|
||||
// initilisation de la variable globale K: qualite d'echantillonnage requise
|
||||
K = K_init; // valeur d'initialisation de K pour commencer prudemment...
|
||||
// Initialize the global variable K: required sampling quality
|
||||
K = K_init; // initial value of K to start carefully
|
||||
coord_type K_prev = K;
|
||||
|
||||
Vertex_handle v1, v2;
|
||||
@@ -2052,7 +2042,7 @@ namespace CGAL {
|
||||
}
|
||||
do
|
||||
{
|
||||
min_K = infinity(); // pour retenir le prochain K necessaire pour progresser...
|
||||
min_K = infinity(); // to store the next K required to progress
|
||||
do
|
||||
{
|
||||
|
||||
@@ -2095,7 +2085,7 @@ namespace CGAL {
|
||||
{
|
||||
new_candidate = compute_value(mem_Ifacet);
|
||||
if ((new_candidate != mem_e_it))
|
||||
// &&(new_candidate.first < NOT_VALID_CANDIDATE))
|
||||
// &&(new_candidate.first < NOT_VALID_CANDIDATE))
|
||||
{
|
||||
IO_edge_type* pnew =
|
||||
set_again_border_elt(key_tmp.first, key_tmp.second,
|
||||
@@ -2111,8 +2101,7 @@ namespace CGAL {
|
||||
(_ordered_border.begin()->first < STANDBY_CANDIDATE_BIS));
|
||||
K_prev = K;
|
||||
K += (std::max)(K_step, min_K - K + eps);
|
||||
// on augmente progressivement le K mais on a deja rempli sans
|
||||
// faire des betises auparavant...
|
||||
// Progressively increase K, but having already filled without issue beforehand
|
||||
}
|
||||
while((!_ordered_border.empty())&&(K <= K)&&(min_K != infinity())&&(K!=K_prev));
|
||||
|
||||
@@ -2125,9 +2114,8 @@ namespace CGAL {
|
||||
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// En principe, si l'allocateur de cellules etait bien fait on aurait pas besoin
|
||||
// de mettre a jour les valeurs rajoutees pour les cellules a la main...
|
||||
|
||||
// In theory, if the cell allocator were properly made, one would not need to manually update
|
||||
// the values added for the cells
|
||||
void
|
||||
re_init_for_free_cells_cache(const Vertex_handle& vh)
|
||||
{
|
||||
@@ -2152,9 +2140,8 @@ namespace CGAL {
|
||||
int index = c->index(vh);
|
||||
Cell_handle neigh = c->neighbor(index);
|
||||
int n_ind = neigh->index(c);
|
||||
neigh->set_smallest_radius(n_ind, -1); // pour obliger le recalcul
|
||||
// si c est selectionnee c'est qu'elle est aussi le mem_IFacet renvoye par
|
||||
// compute_value... donc a swapper aussi
|
||||
neigh->set_smallest_radius(n_ind, -1); // forces recomputation
|
||||
// if c is selected, then it is also the mem_IFacet returned by compute_value... so to be swapped too
|
||||
if (c->is_selected_facet(index))
|
||||
{
|
||||
int fn = c->facet_number(index);
|
||||
@@ -2214,8 +2201,8 @@ namespace CGAL {
|
||||
circ = next(circ);
|
||||
}
|
||||
while(circ.first.first != c);
|
||||
// si on passe par la, alors y a eu un probleme....
|
||||
std::cerr << "+++probleme dans la MAJ avant remove..." << std::endl;
|
||||
// if we are here, something went wrong
|
||||
std::cerr << "+++issue in the update before removal..." << std::endl;
|
||||
return Facet(c, start.second);
|
||||
}
|
||||
|
||||
@@ -2237,7 +2224,7 @@ namespace CGAL {
|
||||
ordered_map_erase(border_elt.second.first.first,
|
||||
border_IO_elt(vh, vh_succ));
|
||||
remove_border_edge(vh, vh_succ);
|
||||
// 1- a virer au cas ou car vh va etre detruit
|
||||
// 1- remove just in case since vh is about to be destroyed
|
||||
remove_interior_edge(vh_succ, vh);
|
||||
bool while_cond(true);
|
||||
do
|
||||
@@ -2266,14 +2253,14 @@ namespace CGAL {
|
||||
{
|
||||
ordered_map_erase(result.first.first, border_IO_elt(vh_int, vh));
|
||||
remove_border_edge(vh_int, vh);
|
||||
// 1- a virer au cas ou car vh va etre detruit
|
||||
// 1- remove just in case since vh is about to be destroyed
|
||||
remove_interior_edge(vh_int, vh);
|
||||
while_cond = false;
|
||||
}
|
||||
// a titre preventif... on essaye de s'assurer de marquer les aretes
|
||||
// interieures au sens large...
|
||||
|
||||
// 2- a virer a tout pris pour que maintenir le sens de interior edge
|
||||
// As a preventive measure, we try to ensure marking the interior edges in a broad sense
|
||||
|
||||
// 2- remove to preserve the interior edge
|
||||
remove_interior_edge(vh_int, vh_succ);
|
||||
remove_interior_edge(vh_succ, vh_int);
|
||||
|
||||
@@ -2304,16 +2291,16 @@ namespace CGAL {
|
||||
bool
|
||||
create_singularity(const Vertex_handle& vh)
|
||||
{
|
||||
// Pour reperer le cas de triangle isole
|
||||
// To detect the isolated triangle case
|
||||
if (vh->is_on_border())
|
||||
{
|
||||
// vh sommet 0
|
||||
// vh vertex 0
|
||||
Next_border_elt border_elt = *(vh->first_incident());
|
||||
Vertex_handle vh_1 = border_elt.first;// sommet 1
|
||||
Vertex_handle vh_1 = border_elt.first;// vertex 1
|
||||
border_elt = *(vh_1->first_incident());
|
||||
Vertex_handle vh_2 = border_elt.first;// sommet 2
|
||||
Vertex_handle vh_2 = border_elt.first;// vertex 2
|
||||
border_elt = *(vh_2->first_incident());
|
||||
Vertex_handle vh_3 = border_elt.first;// sommet 0 ???
|
||||
Vertex_handle vh_3 = border_elt.first;// vertex 0 ???
|
||||
Cell_handle c;
|
||||
int i, j, k;
|
||||
if ((vh_3 == vh)&&(T.is_facet(vh, vh_1, vh_2, c, i ,j ,k)))
|
||||
@@ -2328,7 +2315,7 @@ namespace CGAL {
|
||||
}
|
||||
|
||||
|
||||
// Reperer le cas d'aretes interieures...
|
||||
// Detect the interior edges case
|
||||
std::list<Vertex_handle> vh_list;
|
||||
T.incident_vertices(vh, std::back_inserter(vh_list));
|
||||
|
||||
@@ -2402,9 +2389,9 @@ namespace CGAL {
|
||||
|
||||
std::list<Vertex_handle> L_v;
|
||||
|
||||
// Pour controler les sommets choisis sur le bord...
|
||||
// To control vertices chosen on the boundary
|
||||
|
||||
// nombre d'aretes a partir duquel on considere que c'est irrecuperable NB_BORDER_MAX
|
||||
// NB_BORDER_MAX: number of edges from which we consider that things are irrecoverable
|
||||
|
||||
int vh_on_border_inserted(0);
|
||||
for(Finite_vertices_iterator v_it = T.finite_vertices_begin();
|
||||
@@ -2445,7 +2432,7 @@ namespace CGAL {
|
||||
|
||||
std::size_t itmp, L_v_size_mem;
|
||||
L_v_size_mem = L_v.size();
|
||||
if ((vh_on_border_inserted != 0)&& // pour ne post-traiter que les bords
|
||||
if ((vh_on_border_inserted != 0)&& // to post-process only the borders
|
||||
(L_v.size() < .1 * _size_before_postprocessing))
|
||||
{
|
||||
{
|
||||
@@ -2460,7 +2447,7 @@ namespace CGAL {
|
||||
}
|
||||
#ifdef VERBOSE
|
||||
if(L_v.size() > 0){
|
||||
std::cout << " " << L_v.size() << " non regular points." << std::endl;
|
||||
std::cout << " " << L_v.size() << " non-regular points." << std::endl;
|
||||
}
|
||||
#endif // VERBOSE
|
||||
re_compute_values();
|
||||
@@ -2469,7 +2456,7 @@ namespace CGAL {
|
||||
postprocess_timer.stop();
|
||||
return false;
|
||||
}
|
||||
// we stop if we removed more than 10% of points or after 20 rounds
|
||||
// we stop if we removed more than 10% of points, or after 20 rounds
|
||||
if ((L_v_size_mem == L_v.size())||
|
||||
((_size_before_postprocessing - T.number_of_vertices()) >
|
||||
.1 * _size_before_postprocessing)||
|
||||
@@ -2479,7 +2466,6 @@ namespace CGAL {
|
||||
}
|
||||
|
||||
min_K = infinity();
|
||||
// fin--
|
||||
// if (_postprocessing_counter < 5)
|
||||
// return true;
|
||||
postprocess_timer.stop();
|
||||
|
||||
+1
-1
@@ -220,7 +220,7 @@ namespace CGAL {
|
||||
else
|
||||
{
|
||||
if (m_incident_border->second->first != nullptr)
|
||||
std::cerr << "+++probleme de MAJ du bord <Vertex_base>" << std::endl;
|
||||
std::cerr << "+++issue while updating border <Vertex_base>" << std::endl;
|
||||
*m_incident_border->second = elt;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 );
|
||||
|
||||
@@ -4,15 +4,13 @@ project(Algebraic_kernel_d_Examples)
|
||||
find_package(CGAL REQUIRED COMPONENTS Core)
|
||||
|
||||
find_package(MPFI QUIET)
|
||||
|
||||
if(MPFI_FOUND AND NOT CGAL_DISABLE_GMP)
|
||||
include(${MPFI_USE_FILE})
|
||||
include(CGAL_VersionUtils)
|
||||
create_single_source_cgal_program("Compare_1.cpp")
|
||||
create_single_source_cgal_program("Construct_algebraic_real_1.cpp")
|
||||
create_single_source_cgal_program("Isolate_1.cpp")
|
||||
create_single_source_cgal_program("Sign_at_1.cpp")
|
||||
create_single_source_cgal_program("Solve_1.cpp")
|
||||
else()
|
||||
message(STATUS "This program requires the CGAL, CGAL_Core and MPFI libraries, and will not be compiled.")
|
||||
message("NOTICE: This project requires the MPFI library and GMP support, and will not be compiled.")
|
||||
endif()
|
||||
|
||||
@@ -356,10 +356,10 @@ public:
|
||||
const OuterFunctor& outer)
|
||||
: _inner(inner), _outer(outer) {}
|
||||
|
||||
Unary_compose(const Unary_compose& other)
|
||||
: _inner(other._inner), _outer(other._outer) {}
|
||||
Unary_compose(const Unary_compose& other) = default;
|
||||
Unary_compose& operator=(const Unary_compose& other) = default;
|
||||
|
||||
Unary_compose() : _inner(::boost::none),_outer(::boost::none) {}
|
||||
Unary_compose() : _inner(::boost::none),_outer(::boost::none) {}
|
||||
|
||||
typedef typename InnerFunctor::argument_type argument_type;
|
||||
typedef typename OuterFunctor::result_type result_type;
|
||||
@@ -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
|
||||
|
||||
+2
-2
@@ -45,7 +45,7 @@ namespace internal {
|
||||
* @Unpublished{abbott-quadratic,
|
||||
* author = {John Abbott},
|
||||
* title = {Quadratic Interval Refinement for Real Roots},
|
||||
* url = {http://www.dima.unige.it/~abbott/},
|
||||
* url = {https://www.dima.unige.it/~abbott/},
|
||||
* note = {Poster presented at the 2006 Internat. Sympos. on Symbolic
|
||||
and Algebraic Computation (ISSAC 2006)}
|
||||
* }
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -1147,8 +1147,8 @@ public:
|
||||
Bitstream_descartes() : Base(new Rep()) {}
|
||||
|
||||
//! Copy constructor
|
||||
Bitstream_descartes(const Self& other) : Base(static_cast<const Base&>(other))
|
||||
{}
|
||||
Bitstream_descartes(const Self& other) = default;
|
||||
Bitstream_descartes& operator=(const Self& other) = default;
|
||||
|
||||
/*!
|
||||
* \brief Constructor for a polynomial \c f
|
||||
@@ -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
|
||||
|
||||
@@ -436,6 +436,9 @@ public:
|
||||
friend class CGAL::internal::Bitstream_descartes_E08_tree<TRAITS>;
|
||||
friend class CGAL::internal::Bitstream_descartes_E08_tree_rep<TRAITS>;
|
||||
|
||||
Bitstream_descartes_E08_node(const Self&) = default;
|
||||
Self& operator= (const Self&) = delete;
|
||||
|
||||
private:
|
||||
// "node data" (set individually in subdivision)
|
||||
Integer lower_num_, upper_num_; // TODO use lower_num_, width_num_ instead
|
||||
@@ -443,7 +446,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$
|
||||
@@ -466,8 +469,6 @@ private:
|
||||
log_eps_ = n.log_eps_;
|
||||
log_C_eps_ = n.log_C_eps_;
|
||||
}
|
||||
|
||||
Self& operator= (const Self&) = delete;
|
||||
}; // struct Bitstream_descartes_E08_node
|
||||
|
||||
|
||||
|
||||
@@ -525,13 +525,16 @@ public:
|
||||
friend class internal::Bitstream_descartes_rndl_tree<TRAITS>;
|
||||
friend class internal::Bitstream_descartes_rndl_tree_rep<TRAITS>;
|
||||
|
||||
Bitstream_descartes_rndl_node(const Self&) = default;
|
||||
Self& operator= (const Self&) = delete;
|
||||
|
||||
private:
|
||||
// "node data" (set individually in subdivision)
|
||||
Integer lower_num_, upper_num_; // TODO use lower_num_, width_num_ instead
|
||||
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_;
|
||||
@@ -557,8 +560,6 @@ private:
|
||||
log_eps_ = n.log_eps_;
|
||||
log_C_eps_ = n.log_C_eps_;
|
||||
}
|
||||
|
||||
Self& operator= (const Self&)=delete;
|
||||
}; // struct Bitstream_descartes_rndl_node
|
||||
|
||||
|
||||
@@ -736,7 +737,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 +750,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 +773,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
|
||||
|
||||
@@ -4,48 +4,33 @@ project(Algebraic_kernel_d_Tests)
|
||||
# CGAL and its components
|
||||
find_package(CGAL REQUIRED COMPONENTS Core)
|
||||
|
||||
find_package(RS3 QUIET)
|
||||
|
||||
find_package(MPFI QUIET)
|
||||
if(MPFI_FOUND)
|
||||
message(STATUS "Found MPFI")
|
||||
include(${MPFI_USE_FILE})
|
||||
endif()
|
||||
|
||||
find_package(RS3 QUIET)
|
||||
if(RS3_FOUND)
|
||||
message(STATUS "Found RS3")
|
||||
include(${RS3_USE_FILE})
|
||||
endif()
|
||||
|
||||
# Boost and its components
|
||||
find_package(Boost)
|
||||
|
||||
if(NOT Boost_FOUND)
|
||||
|
||||
message(
|
||||
STATUS "This project requires the Boost library, and will not be compiled.")
|
||||
|
||||
return()
|
||||
|
||||
endif()
|
||||
|
||||
# include for local directory
|
||||
include_directories(BEFORE include)
|
||||
|
||||
# Creating entries for all .cpp/.C files with "main" routine
|
||||
# ##########################################################
|
||||
|
||||
create_single_source_cgal_program("cyclic.cpp")
|
||||
create_single_source_cgal_program("Descartes.cpp")
|
||||
|
||||
if(NOT CGAL_DISABLE_GMP)
|
||||
create_single_source_cgal_program("Algebraic_curve_kernel_2.cpp")
|
||||
create_single_source_cgal_program("algebraic_curve_kernel_2_tools.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_1_LEDA.cpp")
|
||||
|
||||
create_single_source_cgal_program(
|
||||
"Algebraic_kernel_d_1_CORE_Integer_rational.cpp")
|
||||
create_single_source_cgal_program(
|
||||
"Algebraic_kernel_d_1_CORE_SqrtII_rational.cpp")
|
||||
create_single_source_cgal_program(
|
||||
"Algebraic_kernel_d_1_CORE_SqrtRI_rational.cpp")
|
||||
create_single_source_cgal_program(
|
||||
"Algebraic_kernel_d_1_CORE_SqrtRR_rational.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_1_CORE_Integer_rational.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_1_CORE_SqrtII_rational.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_1_CORE_SqrtRI_rational.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_1_CORE_SqrtRR_rational.cpp")
|
||||
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_1_GMP.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_d_2.cpp")
|
||||
@@ -54,14 +39,13 @@ if(NOT CGAL_DISABLE_GMP)
|
||||
create_single_source_cgal_program("Curve_analysis_2.cpp")
|
||||
create_single_source_cgal_program("Curve_pair_analysis_2.cpp")
|
||||
create_single_source_cgal_program("Real_embeddable_traits_extension.cpp")
|
||||
|
||||
if(RS_FOUND)
|
||||
create_single_source_cgal_program("Algebraic_kernel_rs_gmpq_d_1.cpp")
|
||||
create_single_source_cgal_program("Algebraic_kernel_rs_gmpz_d_1.cpp")
|
||||
else()
|
||||
message(
|
||||
STATUS
|
||||
"NOTICE: Some tests require the RS library, and will not be compiled.")
|
||||
message(STATUS "NOTICE: Some tests require the RS library, and will not be compiled.")
|
||||
endif()
|
||||
else()
|
||||
message(STATUS "NOTICE: Some tests require the CGAL_Core library, and will not be compiled.")
|
||||
message(STATUS "NOTICE: Some tests require GMP support, and will not be compiled.")
|
||||
endif()
|
||||
|
||||
@@ -187,7 +187,7 @@ void test_real_root_isolator() {
|
||||
assert( n == number_of_roots);
|
||||
}{
|
||||
//std::cout << "Kameny 3\n";
|
||||
// from http://www-sop.inria.fr/saga/POL/BASE/1.unipol
|
||||
// from https://www-sop.inria.fr/saga/POL/BASE/1.unipol/
|
||||
|
||||
NT c = CGAL::ipower(NT(10),12);
|
||||
Polynomial P(NT(-3),NT(0),c);
|
||||
@@ -202,7 +202,7 @@ void test_real_root_isolator() {
|
||||
assert(3 == internal::check_intervals_real_root_isolator<Isolator>(P));
|
||||
}{
|
||||
//std::cout << "Kameny 4\n";
|
||||
// from http://www-sop.inria.fr/saga/POL/BASE/1.unipol
|
||||
// from https://www-sop.inria.fr/saga/POL/BASE/1.unipol
|
||||
|
||||
NT z(0);
|
||||
NT a = CGAL::ipower(NT(10),24); // a = 10^{24}
|
||||
@@ -218,7 +218,7 @@ void test_real_root_isolator() {
|
||||
assert( 4 == internal::check_intervals_real_root_isolator<Isolator>(P));
|
||||
}{
|
||||
//std::cout << "Polynomial with large and small clustered roots\n";
|
||||
// from http://www-sop.inria.fr/saga/POL/BASE/1.unipol
|
||||
// from https://www-sop.inria.fr/saga/POL/BASE/1.unipol
|
||||
// there seems to be some error or misunderstanding
|
||||
|
||||
NT z(0);
|
||||
|
||||
+1
-1
@@ -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
|
||||
|
||||
+2
-2
@@ -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
|
||||
|
||||
@@ -6,6 +6,7 @@ project(Alpha_shapes_3_Demo)
|
||||
|
||||
# Find includes in corresponding build directories
|
||||
set(CMAKE_INCLUDE_CURRENT_DIR ON)
|
||||
|
||||
# Instruct CMake to run moc automatically when needed.
|
||||
set(CMAKE_AUTOMOC ON)
|
||||
if(NOT POLICY CMP0070 AND POLICY CMP0053)
|
||||
@@ -27,7 +28,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)
|
||||
@@ -46,8 +47,6 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
|
||||
else()
|
||||
|
||||
message(
|
||||
STATUS "NOTICE: This demo requires CGAL, and Qt5, and will not be compiled."
|
||||
)
|
||||
message("NOTICE: This demo requires CGAL and Qt5, and will not be compiled.")
|
||||
|
||||
endif()
|
||||
|
||||
@@ -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();
|
||||
|
||||
|
||||
+1
-1
@@ -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>::
|
||||
|
||||
+7
-7
@@ -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.
|
||||
|
||||
@@ -6,7 +6,7 @@ project(Arithmetic_kernel_Tests)
|
||||
|
||||
find_package(CGAL REQUIRED COMPONENTS Core)
|
||||
|
||||
find_package(GMP QUIET)
|
||||
find_package(GMP)
|
||||
|
||||
if(GMP_FOUND)
|
||||
|
||||
@@ -18,7 +18,7 @@ if(GMP_FOUND)
|
||||
|
||||
include_directories(include)
|
||||
|
||||
find_package(MPFI)
|
||||
find_package(MPFI QUIET)
|
||||
|
||||
if(MPFI_FOUND)
|
||||
include(${MPFI_USE_FILE})
|
||||
@@ -27,16 +27,13 @@ if(GMP_FOUND)
|
||||
# version needs GMP>=4.2, so we require this dependency only here and
|
||||
# not in FindMPFI.cmake
|
||||
if(_IS_GMP_VERSION_TO_LOW)
|
||||
message(
|
||||
STATUS
|
||||
"MPFI tests need GMP>=4.2, some of the tests will not be compiled")
|
||||
message(STATUS "NOTICE: MPFI tests need GMP>=4.2, some of the tests will not be compiled")
|
||||
else(_IS_GMP_VERSION_TO_LOW)
|
||||
include(${MPFI_USE_FILE})
|
||||
create_single_source_cgal_program("GMP_arithmetic_kernel.cpp")
|
||||
endif(_IS_GMP_VERSION_TO_LOW)
|
||||
else(MPFI_FOUND)
|
||||
message(
|
||||
STATUS "MPFI is not present, some of the tests will not be compiled.")
|
||||
message(STATUS "NOTICE: MPFI is not present, some of the tests will not be compiled.")
|
||||
endif(MPFI_FOUND)
|
||||
|
||||
create_single_source_cgal_program("Arithmetic_kernel.cpp")
|
||||
@@ -46,7 +43,6 @@ if(GMP_FOUND)
|
||||
|
||||
else()
|
||||
|
||||
message(
|
||||
STATUS "This program requires the CGAL library, and will not be compiled.")
|
||||
message("NOTICE: This project requires GMP support, and will not be compiled.")
|
||||
|
||||
endif()
|
||||
|
||||
@@ -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; }
|
||||
|
||||
+1
-1
@@ -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;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#ifndef LEXICAL_CAST_HPP
|
||||
#define LEXICAL_CAST_HPP
|
||||
|
||||
/*! This files provides lexical casts from std::string to any one of the number
|
||||
/*! This file provides lexical casts from std::string to any one of the number
|
||||
* types we intend to use in the benchmark, and a lexical cast does not exist.
|
||||
* It is inspired by boost::lexical_cast
|
||||
*/
|
||||
|
||||
@@ -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();
|
||||
|
||||
+1
-1
@@ -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; }
|
||||
|
||||
|
||||
@@ -12,10 +12,10 @@ if(POLICY CMP0071)
|
||||
cmake_policy(SET CMP0071 NEW)
|
||||
endif()
|
||||
|
||||
find_package(CGAL QUIET COMPONENTS Qt5 OPTIONAL_COMPONENTS Core)
|
||||
find_package(CGAL REQUIRED OPTIONAL_COMPONENTS Core Qt5)
|
||||
find_package(Qt5 QUIET COMPONENTS Gui Widgets)
|
||||
|
||||
if (CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
if (CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
include(${CGAL_USE_FILE})
|
||||
add_compile_definitions(QT_NO_KEYWORDS)
|
||||
include_directories( BEFORE ./ )
|
||||
@@ -110,10 +110,10 @@ if (CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
${CGAL_Qt5_RESOURCE_FILES}
|
||||
${CGAL_Qt5_MOC_FILES})
|
||||
|
||||
target_link_libraries(arrangement_2 Qt5::Core Qt5::Gui Qt5::Widgets)
|
||||
target_link_libraries(arrangement_2 CGAL::CGAL CGAL::CGAL_Qt5)
|
||||
target_link_libraries(arrangement_2 PRIVATE Qt5::Core Qt5::Gui Qt5::Widgets)
|
||||
target_link_libraries(arrangement_2 PRIVATE CGAL::CGAL CGAL::CGAL_Qt5)
|
||||
if(CGAL_Core_FOUND)
|
||||
target_link_libraries(arrangement_2 CGAL::CGAL_Core)
|
||||
target_link_libraries(arrangement_2 PRIVATE CGAL::CGAL_Core)
|
||||
endif()
|
||||
|
||||
add_to_cached_list(CGAL_EXECUTABLE_TARGETS arrangement_2)
|
||||
@@ -124,15 +124,11 @@ if (CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND)
|
||||
else()
|
||||
set(MISSING_DEPS "")
|
||||
|
||||
if(NOT CGAL_FOUND)
|
||||
set(MISSING_DEPS "CGAL, ${MISSING_DEPS}")
|
||||
endif()
|
||||
if(NOT CGAL_Qt5_FOUND)
|
||||
set(MISSING_DEPS "the CGAL Qt5 library, ${MISSING_DEPS}")
|
||||
endif()
|
||||
if(NOT Qt5_FOUND)
|
||||
set(MISSING_DEPS "Qt5, ${MISSING_DEPS}")
|
||||
endif()
|
||||
message(STATUS
|
||||
"NOTICE: This demo requires ${MISSING_DEPS} and will not be compiled.")
|
||||
message("NOTICE: This demo requires ${MISSING_DEPS} and will not be compiled.")
|
||||
endif()
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
** Foundation and appearing in the file LICENSE.LGPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU Lesser General Public License version 2.1 requirements
|
||||
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
** will be met: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** In addition, as a special exception, Nokia gives you certain additional
|
||||
** rights. These rights are described in the Nokia Qt LGPL Exception
|
||||
@@ -31,7 +31,7 @@
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
** met: https://www.gnu.org/licenses/gpl-3.0.html.
|
||||
**
|
||||
** If you have questions regarding the use of this file, please contact
|
||||
** Nokia at qt-info@nokia.com.
|
||||
|
||||
@@ -19,7 +19,7 @@
|
||||
** Foundation and appearing in the file LICENSE.LGPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU Lesser General Public License version 2.1 requirements
|
||||
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
** will be met: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** In addition, as a special exception, Nokia gives you certain additional
|
||||
** rights. These rights are described in the Nokia Qt LGPL Exception
|
||||
@@ -31,7 +31,7 @@
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
** met: https://www.gnu.org/licenses/gpl-3.0.html.
|
||||
**
|
||||
** If you have questions regarding the use of this file, please contact
|
||||
** Nokia at qt-info@nokia.com.
|
||||
|
||||
@@ -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<
|
||||
|
||||
@@ -203,7 +203,7 @@ bool move_isolated_vertex(Face_handle f1, Face_handle f2, Vertex_handle v);
|
||||
/*! relocates all inner ccbs and isolated vertices to their proper position
|
||||
* immediately after a face has split due to the insertion of a new halfedge,
|
||||
* namely after `insert_at_vertices_ex()` was invoked and indicated that a new
|
||||
* face has been created. `he` is the halfegde returned by
|
||||
* face has been created. `he` is the halfedge returned by
|
||||
* `insert_at_vertices_ex()`, such that `he->twin()->face` is the face that has
|
||||
* just been split and `he->face()` is the newly created face.
|
||||
*/
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
+2
-2
@@ -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
|
||||
|
||||
+2
-2
@@ -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
|
||||
|
||||
+1
-1
@@ -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
|
||||
|
||||
+2
-2
@@ -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.
|
||||
*/
|
||||
|
||||
+1
-1
@@ -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`
|
||||
|
||||
+1
-1
@@ -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();
|
||||
|
||||
|
||||
+1
-1
@@ -131,7 +131,7 @@ void read_x_monotone_curve(X_monotone_curve_2& c);
|
||||
/*! reads an auxiliary halfedge-data object and associates it with the halfedge
|
||||
* `he`.
|
||||
*/
|
||||
void read_halfegde_data(Halfedge_handle he);
|
||||
void read_halfedge_data(Halfedge_handle he);
|
||||
|
||||
/*! reads a message indicating the beginning of a single face record. */
|
||||
void read_face_begin();
|
||||
|
||||
+1
-1
@@ -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.
|
||||
*
|
||||
|
||||
+1
-1
@@ -124,7 +124,7 @@ void write_halfedge_index (std::size_t idx);
|
||||
void write_x_monotone_curve (const X_monotone_curve_2& c);
|
||||
|
||||
/*! writes the auxiliary data associated with the halfedge. */
|
||||
void write_halfegde_data (Halfedge_const_handle he);
|
||||
void write_halfedge_data (Halfedge_const_handle he);
|
||||
|
||||
/*! writes a message indicating the beginning of a single face record. */
|
||||
void write_face_begin();
|
||||
|
||||
+2
-2
@@ -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 =
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user