mirror of https://github.com/CGAL/cgal
putting all parameters in common struct
This commit is contained in:
Dmitry Anisimov
parent
87c6631b5e
commit
acb8bae90e
|
|
@ -222,6 +222,7 @@ CGAL_add_named_parameter(k_intersections_t, k_intersections, k_intersections)
|
|||
CGAL_add_named_parameter(n_subdivisions_t, n_subdivisions, n_subdivisions)
|
||||
CGAL_add_named_parameter(enlarge_bbox_ratio_t, enlarge_bbox_ratio, enlarge_bbox_ratio)
|
||||
CGAL_add_named_parameter(reorient_t, reorient, reorient)
|
||||
CGAL_add_named_parameter(use_hybrid_mode_t, use_hybrid_mode, use_hybrid_mode)
|
||||
|
||||
// region growing
|
||||
CGAL_add_named_parameter(k_neighbors_t, k_neighbors, k_neighbors)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#ifndef CGAL_KSR_PARAMETERS_H
|
||||
#define CGAL_KSR_PARAMETERS_H
|
||||
#ifndef CGAL_KSR_ALL_PARAMETERS_EXAMPLES_H
|
||||
#define CGAL_KSR_ALL_PARAMETERS_EXAMPLES_H
|
||||
|
||||
// STL includes.
|
||||
#include <string>
|
||||
|
|
@ -8,7 +8,7 @@ namespace CGAL {
|
|||
namespace KSR {
|
||||
|
||||
template<typename FT>
|
||||
struct Parameters {
|
||||
struct All_parameters {
|
||||
|
||||
// Path to the input data file.
|
||||
std::string data;
|
||||
|
|
@ -46,7 +46,7 @@ namespace KSR {
|
|||
FT graphcut_beta;
|
||||
|
||||
// Constructor.
|
||||
Parameters() :
|
||||
All_parameters() :
|
||||
data(""),
|
||||
gi("0"), bi("1"), ii("2"), vi("3"),
|
||||
// main parameters
|
||||
|
|
@ -80,4 +80,4 @@ namespace KSR {
|
|||
} // KSR
|
||||
} // CGAL
|
||||
|
||||
#endif // CGAL_KSR_PARAMETERS_H
|
||||
#endif // CGAL_KSR_ALL_PARAMETERS_EXAMPLES_H
|
||||
|
|
|
|||
|
|
@ -96,7 +96,8 @@ int main(const int argc, const char** argv) {
|
|||
k_intersections(k).
|
||||
n_subdivisions(subdiv).
|
||||
enlarge_bbox_ratio(eratio).
|
||||
reorient(orient));
|
||||
reorient(orient).
|
||||
use_hybrid_mode(true));
|
||||
assert(is_ksr_success);
|
||||
const std::string success = is_ksr_success ? "SUCCESS" : "FAILED";
|
||||
timer.stop();
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ using Semantic_map = CGAL::KSR::Semantic_from_label_map<Label_map>;
|
|||
|
||||
using KSR = CGAL::Kinetic_shape_reconstruction_3<Kernel>;
|
||||
|
||||
using Parameters = CGAL::KSR::Parameters<FT>;
|
||||
using Parameters = CGAL::KSR::All_parameters<FT>;
|
||||
using Terminal_parser = CGAL::KSR::Terminal_parser<FT>;
|
||||
using Timer = CGAL::Real_timer;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
// Copyright (c) 2021 GeometryFactory SARL (France).
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of CGAL (www.cgal.org).
|
||||
//
|
||||
// $URL$
|
||||
// $Id$
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
|
||||
//
|
||||
//
|
||||
// Author(s) : Dmitry Anisimov
|
||||
|
||||
#ifndef CGAL_KSR_CONVERSIONS_H
|
||||
#define CGAL_KSR_CONVERSIONS_H
|
||||
|
||||
// #include <CGAL/license/Kinetic_shape_reconstruction.h>
|
||||
|
||||
// STL includes.
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
|
||||
namespace CGAL {
|
||||
namespace KSR {
|
||||
|
||||
|
||||
} // namespace KSR
|
||||
} // namespace CGAL
|
||||
|
||||
#endif // CGAL_KSR_CONVERSIONS_H
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
// Copyright (c) 2021 GeometryFactory SARL (France).
|
||||
// All rights reserved.
|
||||
//
|
||||
// This file is part of CGAL (www.cgal.org).
|
||||
//
|
||||
// $URL$
|
||||
// $Id$
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
|
||||
//
|
||||
//
|
||||
// Author(s) : Dmitry Anisimov
|
||||
|
||||
#ifndef CGAL_KSR_PARAMETERS_H
|
||||
#define CGAL_KSR_PARAMETERS_H
|
||||
|
||||
// #include <CGAL/license/Kinetic_shape_reconstruction.h>
|
||||
|
||||
namespace CGAL {
|
||||
namespace KSR {
|
||||
|
||||
template<typename FT>
|
||||
struct Parameters_3 {
|
||||
|
||||
unsigned int k = 1; // k intersections
|
||||
unsigned int n = 0; // n subdivisions
|
||||
|
||||
FT enlarge_bbox_ratio = FT(11) / FT(10); // ratio to enlarge bbox
|
||||
|
||||
bool reorient = false; // true - optimal bounding box, false - axis aligned
|
||||
bool use_hybrid_mode = false; // true - apply exact interesections while all other computations are inexact
|
||||
|
||||
bool verbose = true; // print basic verbose information
|
||||
bool debug = false; // print all steps and substeps + export initial and final configurations
|
||||
bool export_all = false; // export all intermediate configurations and events
|
||||
|
||||
// See also global tolerance inside utils.h!
|
||||
Parameters_3(const bool v = true, const bool d = false, const bool e = false) :
|
||||
verbose(v), debug(d), export_all(e) { }
|
||||
};
|
||||
|
||||
} // namespace KSR
|
||||
} // namespace CGAL
|
||||
|
||||
#endif // CGAL_KSR_PARAMETERS_H
|
||||
|
|
@ -88,7 +88,7 @@ point_3_from_point_2(const Point_2& point_2) {
|
|||
point_2.x(), point_2.y(), typename Kernel_traits<Point_2>::Kernel::FT(0));
|
||||
}
|
||||
|
||||
// Tolerance.
|
||||
// Global tolerance.
|
||||
template<typename FT>
|
||||
static FT tolerance() {
|
||||
return FT(1) / FT(100000);
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include <CGAL/KSR/enum.h>
|
||||
#include <CGAL/KSR/utils.h>
|
||||
#include <CGAL/KSR/debug.h>
|
||||
#include <CGAL/KSR/parameters.h>
|
||||
|
||||
#include <CGAL/KSR_3/Support_plane.h>
|
||||
#include <CGAL/KSR_3/Intersection_graph.h>
|
||||
|
|
@ -46,7 +47,9 @@ private:
|
|||
using Triangle_2 = typename Kernel::Triangle_2;
|
||||
using Line_2 = typename Kernel::Line_2;
|
||||
using Plane_3 = typename Kernel::Plane_3;
|
||||
using Polygon_2 = CGAL::Polygon_2<Kernel>;
|
||||
|
||||
using Polygon_2 = CGAL::Polygon_2<Kernel>;
|
||||
using Parameters = KSR::Parameters_3<FT>;
|
||||
|
||||
public:
|
||||
using Support_plane = KSR_3::Support_plane<Kernel>;
|
||||
|
|
@ -201,9 +204,9 @@ private:
|
|||
using Limit_line = std::vector< std::pair< std::pair<std::size_t, std::size_t>, bool> >;
|
||||
std::vector<Limit_line> m_limit_lines;
|
||||
|
||||
const Parameters& m_parameters;
|
||||
FT m_previous_time;
|
||||
FT m_current_time;
|
||||
bool m_verbose;
|
||||
|
||||
std::vector<Volume_cell> m_volumes;
|
||||
std::map<int, std::size_t> m_volume_level_map;
|
||||
|
|
@ -212,10 +215,10 @@ private:
|
|||
Reconstructed_model m_reconstructed_model;
|
||||
|
||||
public:
|
||||
Data_structure(const bool verbose) :
|
||||
Data_structure(const Parameters& parameters) :
|
||||
m_parameters(parameters),
|
||||
m_previous_time(FT(0)),
|
||||
m_current_time(FT(0)),
|
||||
m_verbose(verbose)
|
||||
m_current_time(FT(0))
|
||||
{ }
|
||||
|
||||
/*******************************
|
||||
|
|
@ -346,7 +349,7 @@ public:
|
|||
// pairs.push_back(std::make_pair(std::make_pair(sp_idx_2, sp_idx_1), false));
|
||||
|
||||
++num_1_intersected;
|
||||
// if (m_verbose) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "pair 1: " << std::to_string(sp_idx_1) << "/" << std::to_string(sp_idx_2) << std::endl;
|
||||
// }
|
||||
// CGAL_assertion_msg(false, "TODO: 1 POLYGON IS INTERSECTED!");
|
||||
|
|
@ -363,7 +366,7 @@ public:
|
|||
pairs.push_back(std::make_pair(std::make_pair(sp_idx_1, sp_idx_2), false));
|
||||
pairs.push_back(std::make_pair(std::make_pair(sp_idx_2, sp_idx_1), false));
|
||||
++num_2_intersected;
|
||||
// if (m_verbose) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "pair 1: " << std::to_string(sp_idx_1) << "/" << std::to_string(sp_idx_2) << std::endl;
|
||||
// std::cout << "pair 2: " << std::to_string(sp_idx_2) << "/" << std::to_string(sp_idx_1) << std::endl;
|
||||
// }
|
||||
|
|
@ -377,7 +380,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- num 1 intersected: " << num_1_intersected << std::endl;
|
||||
std::cout << "- num 2 intersected: " << num_2_intersected << std::endl;
|
||||
}
|
||||
|
|
@ -1085,14 +1088,14 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- iedges, front: " << fiedges.size() << std::endl;
|
||||
for (const auto& fiedge : fiedges) {
|
||||
std::cout << str(fiedge) << ": " << segment_3(fiedge) << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_verbose ) {
|
||||
if (m_parameters.debug ) {
|
||||
std::cout << "- iedges, back: " << biedges.size() << std::endl;
|
||||
for (const auto& biedge : biedges) {
|
||||
std::cout << str(biedge) << ": " << segment_3(biedge) << std::endl;
|
||||
|
|
@ -1103,7 +1106,7 @@ public:
|
|||
|
||||
const std::pair<PVertex, PVertex> front_and_back_34(const PVertex& pvertex) {
|
||||
|
||||
if (m_verbose) std::cout << "- front back 34 case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front back 34 case" << std::endl;
|
||||
PVertex front, back;
|
||||
const std::size_t sp_idx = pvertex.first;
|
||||
CGAL_assertion(sp_idx != KSR::no_element());
|
||||
|
|
@ -1125,7 +1128,7 @@ public:
|
|||
const std::pair<PVertex, PVertex> front_and_back_5(
|
||||
const PVertex& pvertex1, const PVertex& pvertex2) {
|
||||
|
||||
if (m_verbose) std::cout << "- front back 5 case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front back 5 case" << std::endl;
|
||||
PVertex front, back;
|
||||
CGAL_assertion(pvertex1.first == pvertex2.first);
|
||||
const std::size_t sp_idx = pvertex1.first;
|
||||
|
|
@ -1308,7 +1311,7 @@ public:
|
|||
std::vector< std::pair<IEdge, bool> >& iedges,
|
||||
std::vector<PVertex>& pvertices) {
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "**** traversing iedges global" << std::endl;
|
||||
std::cout << "- k intersections before: " << this->k(pvertex.first) << std::endl;
|
||||
}
|
||||
|
|
@ -1320,11 +1323,11 @@ public:
|
|||
for (std::size_t i = 0; i < iedges.size() - 1; ++i) {
|
||||
|
||||
if (iedges[i].second) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- break iedge " << std::to_string(i) << std::endl;
|
||||
} break;
|
||||
} else {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- handle iedge " << std::to_string(i) << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -1343,20 +1346,20 @@ public:
|
|||
is_limit_line = update_limit_lines_and_k(pvertex, iedge_i, is_occupied_iedge);
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- bbox: " << is_bbox_reached << "; " <<
|
||||
" limit: " << is_limit_line << "; " <<
|
||||
" occupied: " << is_occupied_iedge << std::endl;
|
||||
}
|
||||
|
||||
if (is_bbox_reached) {
|
||||
if (m_verbose) std::cout << "- bbox, stop" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- bbox, stop" << std::endl;
|
||||
break;
|
||||
} else if (is_limit_line) {
|
||||
if (m_verbose) std::cout << "- limit, stop" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- limit, stop" << std::endl;
|
||||
break;
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- free, any k, continue" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- free, any k, continue" << std::endl;
|
||||
const std::size_t ip = i + 1;
|
||||
const auto& iedge_ip = iedges[ip].first;
|
||||
CGAL_assertion_msg(KSR::distance(
|
||||
|
|
@ -1376,7 +1379,7 @@ public:
|
|||
iedges.back().second = true;
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- num added pfaces: " << num_added_pfaces << std::endl;
|
||||
std::cout << "- k intersections after: " << this->k(pvertex.first) << std::endl;
|
||||
}
|
||||
|
|
@ -1392,14 +1395,14 @@ public:
|
|||
const bool is_open, const bool reverse, const std::size_t idx, const IEdge& iedge,
|
||||
std::vector<PVertex>& pvertices) {
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- adding new pface: " << std::endl;
|
||||
}
|
||||
|
||||
// The first pvertex of the new triangle.
|
||||
const auto& pv1 = pvertices[idx];
|
||||
CGAL_assertion(pv1 != null_pvertex());
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- pv1 " << str(pv1) << ": " << point_3(pv1) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1416,7 +1419,7 @@ public:
|
|||
pv2 = pvertices[idx + 1];
|
||||
}
|
||||
CGAL_assertion(pv2 != null_pvertex());
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- pv2 " << str(pv2) << ": " << point_3(pv2) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1434,28 +1437,28 @@ public:
|
|||
const bool is_open, const std::size_t idx, const IEdge& iedge,
|
||||
std::vector<PVertex>& pvertices) {
|
||||
|
||||
if (m_verbose) std::cout << "- creating new pvertex" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- creating new pvertex" << std::endl;
|
||||
|
||||
bool is_parallel = false;
|
||||
Point_2 future_point; Vector_2 future_direction;
|
||||
|
||||
if (!is_open) {
|
||||
if (m_verbose) std::cout << "- handling back/front case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- handling back/front case" << std::endl;
|
||||
is_parallel = compute_future_point_and_direction(
|
||||
0, ivertex, pv_prev, pv_next, iedge, future_point, future_direction);
|
||||
if (is_parallel) {
|
||||
if (m_verbose) std::cout << "- new pvertex, back/front, parallel/reverse case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, back/front, parallel/reverse case" << std::endl;
|
||||
CGAL_assertion_msg(!is_parallel,
|
||||
"TODO: CREATE PVERTEX, BACK/FRONT, ADD PARALLEL CASE!");
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- new pvertex, back/front, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, back/front, standard case" << std::endl;
|
||||
}
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- handling open case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- handling open case" << std::endl;
|
||||
is_parallel = compute_future_point_and_direction(
|
||||
pvertex, ivertex, pv_prev, pv_next, iedge, future_point, future_direction);
|
||||
if (is_parallel) {
|
||||
if (m_verbose) std::cout << "- new pvertex, open, parallel/reverse case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, open, parallel/reverse case" << std::endl;
|
||||
|
||||
IEdge prev_iedge = null_iedge();
|
||||
IEdge next_iedge = null_iedge();
|
||||
|
|
@ -1467,21 +1470,21 @@ public:
|
|||
}
|
||||
|
||||
if (prev_iedge == iedge) {
|
||||
if (m_verbose) std::cout << "- new pvertex, open, prev, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, open, prev, parallel case" << std::endl;
|
||||
CGAL_assertion_msg(!is_parallel, "TODO: CREATE_PVERTEX, OPEN, PREV, ADD PARALLEL CASE!");
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- new pvertex, open, prev, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, open, prev, standard case" << std::endl;
|
||||
}
|
||||
|
||||
if (next_iedge == iedge) {
|
||||
if (m_verbose) std::cout << "- new pvertex, open, next, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, open, next, parallel case" << std::endl;
|
||||
CGAL_assertion_msg(!is_parallel, "TODO: CREATE_PVERTEX, OPEN, NEXT, ADD PARALLEL CASE!");
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- new pvertex, open, next, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, open, next, standard case" << std::endl;
|
||||
}
|
||||
CGAL_assertion_msg(!is_parallel, "TODO: CREATE_PVERTEX, OPEN, ADD PARALLEL CASE!");
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- new pvertex, open, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- new pvertex, open, standard case" << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1689,9 +1692,6 @@ public:
|
|||
|
||||
bool is_active(const PVertex& pvertex) const { return support_plane(pvertex).is_active(pvertex.second); }
|
||||
|
||||
bool is_verbose() const { return m_verbose; }
|
||||
void set_verbose(const bool verbose) { m_verbose = verbose; }
|
||||
|
||||
void deactivate(const PVertex& pvertex) {
|
||||
|
||||
support_plane(pvertex).set_active(pvertex.second, false);
|
||||
|
|
@ -2021,7 +2021,7 @@ public:
|
|||
std::vector<PVertex> pvertices_around_ivertex(
|
||||
const PVertex& pvertex, const IVertex& ivertex) const {
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "** searching pvertices around " << str(pvertex) << " wrt " << str(ivertex) << std::endl;
|
||||
std::cout << "- pvertex: " << point_3(pvertex) << std::endl;
|
||||
|
|
@ -2031,7 +2031,7 @@ public:
|
|||
std::deque<PVertex> pvertices;
|
||||
pvertices.push_back(pvertex);
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
const auto iedge = this->iedge(pvertex);
|
||||
if (iedge != null_iedge()) {
|
||||
std::cout << "- came from: " << str(iedge) << " " << segment_3(iedge) << std::endl;
|
||||
|
|
@ -2084,7 +2084,7 @@ public:
|
|||
// std::cout << "dot: " << dot_product << std::endl;
|
||||
|
||||
if (dot_product < FT(0)) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- " << str(current) << " is backwards" << std::endl;
|
||||
// std::cout << point_3(current) << std::endl;
|
||||
}
|
||||
|
|
@ -2092,7 +2092,7 @@ public:
|
|||
}
|
||||
|
||||
if (is_frozen(current)) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- " << str(current) << " is frozen" << std::endl;
|
||||
// std::cout << point_3(current) << std::endl;
|
||||
}
|
||||
|
|
@ -2102,7 +2102,7 @@ public:
|
|||
}
|
||||
|
||||
if (previous_was_free && is_free) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- " << str(current) << " has no iedge, stopping there" << std::endl;
|
||||
// std::cout << point_3(current) << std::endl;
|
||||
}
|
||||
|
|
@ -2110,12 +2110,12 @@ public:
|
|||
}
|
||||
|
||||
if (is_free) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- " << str(current) << " has no iedge" << std::endl;
|
||||
// std::cout << point_3(current) << std::endl;
|
||||
}
|
||||
} else {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- " << str(current) << " has iedge " << str(iedge)
|
||||
<< " from " << str(source(iedge)) << " to " << str(target(iedge)) << std::endl;
|
||||
// std::cout << segment_3(iedge) << std::endl;
|
||||
|
|
@ -2148,7 +2148,7 @@ public:
|
|||
std::copy(pvertices.begin(), pvertices.end(),
|
||||
std::back_inserter(crossed_pvertices));
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- found " << crossed_pvertices.size() <<
|
||||
" pvertices ready to be merged: " << std::endl;
|
||||
for (const auto& crossed_pvertex : crossed_pvertices) {
|
||||
|
|
@ -2358,12 +2358,12 @@ public:
|
|||
|
||||
if (is_ok_1 && is_ok_2) {
|
||||
is_limit_line = item.second;
|
||||
if (m_verbose) std::cout << "- found intersection " << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- found intersection " << std::endl;
|
||||
return is_limit_line;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- first time intersection" << std::endl;
|
||||
std::cout << "- adding pair: " << std::to_string(sp_idx_1) << "-" << std::to_string(sp_idx_2);
|
||||
}
|
||||
|
|
@ -2371,17 +2371,17 @@ public:
|
|||
CGAL_assertion(pairs.size() < 2);
|
||||
if (is_occupied_iedge) {
|
||||
if (this->k(pvertex.first) == 1) {
|
||||
if (m_verbose) std::cout << ", occupied, TRUE" << std::endl;
|
||||
if (m_parameters.debug) std::cout << ", occupied, TRUE" << std::endl;
|
||||
is_limit_line = true;
|
||||
pairs.push_back(std::make_pair(std::make_pair(sp_idx_1, sp_idx_2), is_limit_line));
|
||||
} else {
|
||||
if (m_verbose) std::cout << ", occupied, FALSE" << std::endl;
|
||||
if (m_parameters.debug) std::cout << ", occupied, FALSE" << std::endl;
|
||||
is_limit_line = false;
|
||||
pairs.push_back(std::make_pair(std::make_pair(sp_idx_1, sp_idx_2), is_limit_line));
|
||||
this->k(pvertex.first)--;
|
||||
}
|
||||
} else {
|
||||
if (m_verbose) std::cout << ", free, FALSE" << std::endl;
|
||||
if (m_parameters.debug) std::cout << ", free, FALSE" << std::endl;
|
||||
is_limit_line = false;
|
||||
pairs.push_back(std::make_pair(std::make_pair(sp_idx_1, sp_idx_2), is_limit_line));
|
||||
}
|
||||
|
|
@ -2415,7 +2415,7 @@ public:
|
|||
|
||||
const FT vec_dot = vec1 * vec2;
|
||||
const bool is_reversed = (vec_dot < FT(0));
|
||||
if (is_reversed && m_verbose) {
|
||||
if (is_reversed && m_parameters.debug) {
|
||||
std::cout << "- found reversed future direction" << std::endl;
|
||||
}
|
||||
return is_reversed;
|
||||
|
|
@ -2879,7 +2879,7 @@ public:
|
|||
|
||||
bool is_reversed = false;
|
||||
if (CGAL::abs(m1 - m3) >= tol) {
|
||||
if (m_verbose) std::cout << "- prev intersected lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev intersected lines" << std::endl;
|
||||
const bool is_a_found = KSR::intersection(
|
||||
future_line_prev, iedge_line, future_point_a);
|
||||
if (!is_a_found) {
|
||||
|
|
@ -2888,7 +2888,7 @@ public:
|
|||
CGAL_assertion_msg(false, "TODO: CAN WE EVER BE HERE? WHY?");
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- intersected point: " << to_3d(sp_idx, future_point_a) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -2902,16 +2902,16 @@ public:
|
|||
}
|
||||
|
||||
if (CGAL::abs(m1 - m3) < tol || is_reversed) {
|
||||
if (m_verbose) std::cout << "- prev parallel lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev parallel lines" << std::endl;
|
||||
is_parallel_prev = true;
|
||||
// Here, in the dot product, we can have maximum 1 zero-length vector.
|
||||
const FT prev_dot = current_vec_prev * iedge_vec;
|
||||
if (prev_dot < FT(0)) {
|
||||
if (m_verbose) std::cout << "- prev moves backwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev moves backwards" << std::endl;
|
||||
future_point_a = target_p;
|
||||
// std::cout << point_3(target(iedge)) << std::endl;
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- prev moves forwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev moves forwards" << std::endl;
|
||||
future_point_a = source_p;
|
||||
// std::cout << point_3(source(iedge)) << std::endl;
|
||||
}
|
||||
|
|
@ -2922,7 +2922,7 @@ public:
|
|||
CGAL_assertion(future_direction_a != Vector_2());
|
||||
future_point_a = pinit - m_current_time * future_direction_a;
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
auto tmp_a = future_direction_a;
|
||||
tmp_a = KSR::normalize(tmp_a);
|
||||
std::cout << "- prev future point a: " <<
|
||||
|
|
@ -2932,7 +2932,7 @@ public:
|
|||
|
||||
is_reversed = false;
|
||||
if (CGAL::abs(m2 - m3) >= tol) {
|
||||
if (m_verbose) std::cout << "- next intersected lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- next intersected lines" << std::endl;
|
||||
const bool is_b_found = KSR::intersection(
|
||||
future_line_next, iedge_line, future_point_b);
|
||||
if (!is_b_found) {
|
||||
|
|
@ -2941,7 +2941,7 @@ public:
|
|||
CGAL_assertion_msg(false, "TODO: CAN WE EVER BE HERE? WHY?");
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- intersected point: " << to_3d(sp_idx, future_point_b) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -2955,16 +2955,16 @@ public:
|
|||
}
|
||||
|
||||
if (CGAL::abs(m2 - m3) < tol || is_reversed) {
|
||||
if (m_verbose) std::cout << "- next parallel lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- next parallel lines" << std::endl;
|
||||
is_parallel_next = true;
|
||||
// Here, in the dot product, we can have maximum 1 zero-length vector.
|
||||
const FT next_dot = current_vec_next * iedge_vec;
|
||||
if (next_dot < FT(0)) {
|
||||
if (m_verbose) std::cout << "- next moves backwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- next moves backwards" << std::endl;
|
||||
future_point_b = target_p;
|
||||
// std::cout << point_3(target(iedge)) << std::endl;
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- next moves forwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- next moves forwards" << std::endl;
|
||||
future_point_b = source_p;
|
||||
// std::cout << point_3(source(iedge)) << std::endl;
|
||||
}
|
||||
|
|
@ -2975,7 +2975,7 @@ public:
|
|||
CGAL_assertion(future_direction_b != Vector_2());
|
||||
future_point_b = pinit - m_current_time * future_direction_b;
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
auto tmp_b = future_direction_b;
|
||||
tmp_b = KSR::normalize(tmp_b);
|
||||
std::cout << "- next future point b: " <<
|
||||
|
|
@ -3100,9 +3100,9 @@ public:
|
|||
|
||||
bool is_reversed = false;
|
||||
if (CGAL::abs(m2 - m3) >= tol) {
|
||||
if (m_verbose) std::cout << "- back/front intersected lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back/front intersected lines" << std::endl;
|
||||
future_point = KSR::intersection<Point_2>(future_line_next, iedge_line);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- intersected point: " << to_3d(sp_idx, future_point) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -3113,27 +3113,27 @@ public:
|
|||
}
|
||||
|
||||
const FT back_front_distance = KSR::distance(pinit, future_point);
|
||||
if (m_verbose) std::cout << "- back/front distance: " << back_front_distance << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back/front distance: " << back_front_distance << std::endl;
|
||||
CGAL_assertion(back_front_distance >= FT(0));
|
||||
// It can still miss this tolerance and then we enter parallel case and fail!
|
||||
const FT reversed_tol = tol * FT(1000);
|
||||
if (is_reversed && back_front_distance < reversed_tol) {
|
||||
is_reversed = false;
|
||||
if (m_verbose) std::cout << "- back/front reversed, imprecise computation" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back/front reversed, imprecise computation" << std::endl;
|
||||
CGAL_assertion_msg(false, "TODO: BACK/FRONT HANDLE REVERSED CASE!");
|
||||
}
|
||||
|
||||
if (CGAL::abs(m2 - m3) < tol || is_reversed) {
|
||||
if (m_verbose) std::cout << "- back/front parallel lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back/front parallel lines" << std::endl;
|
||||
is_parallel = true;
|
||||
// Here, in the dot product, we can have maximum 1 zero-length vector.
|
||||
const FT next_dot = current_vec_next * iedge_vec;
|
||||
if (next_dot < FT(0)) {
|
||||
if (m_verbose) std::cout << "- back/front moves backwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back/front moves backwards" << std::endl;
|
||||
future_point = target_p;
|
||||
// std::cout << point_3(target(iedge)) << std::endl;
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- back/front moves forwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back/front moves forwards" << std::endl;
|
||||
future_point = source_p;
|
||||
// std::cout << point_3(source(iedge)) << std::endl;
|
||||
}
|
||||
|
|
@ -3144,7 +3144,7 @@ public:
|
|||
CGAL_assertion(future_direction != Vector_2());
|
||||
future_point = pinit - m_current_time * future_direction;
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
auto tmp = future_direction;
|
||||
tmp = KSR::normalize(tmp);
|
||||
std::cout << "- back/front future point: " <<
|
||||
|
|
@ -3222,9 +3222,9 @@ public:
|
|||
|
||||
bool is_reversed = false;
|
||||
if (CGAL::abs(m2 - m3) >= tol) {
|
||||
if (m_verbose) std::cout << "- open intersected lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open intersected lines" << std::endl;
|
||||
future_point = KSR::intersection<Point_2>(future_line_next, iedge_line);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- intersected point: " << to_3d(sp_idx, future_point) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -3235,7 +3235,7 @@ public:
|
|||
}
|
||||
|
||||
const FT open_distance = KSR::distance(pinit, future_point);
|
||||
if (m_verbose) std::cout << "- open distance: " << open_distance << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open distance: " << open_distance << std::endl;
|
||||
CGAL_assertion(open_distance >= FT(0));
|
||||
// It can still miss this tolerance and then we enter parallel case and fail!
|
||||
const FT reversed_tol = tol * FT(1000);
|
||||
|
|
@ -3244,19 +3244,19 @@ public:
|
|||
// auto nvec = Vector_2(future_point, pinit);
|
||||
// nvec = KSR::normalize(nvec);
|
||||
// future_point = pinit + tol * nvec; // not a valid solution, tested
|
||||
if (m_verbose) std::cout << "- open reversed, imprecise computation" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open reversed, imprecise computation" << std::endl;
|
||||
CGAL_assertion_msg(false, "TODO: OPEN HANDLE REVERSED CASE!");
|
||||
}
|
||||
|
||||
if (CGAL::abs(m2 - m3) < tol || is_reversed) {
|
||||
if (m_verbose) std::cout << "- open parallel lines" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open parallel lines" << std::endl;
|
||||
is_parallel = true;
|
||||
if (source_p == pv_point) {
|
||||
if (m_verbose) std::cout << "- open moves backwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open moves backwards" << std::endl;
|
||||
future_point = target_p;
|
||||
// std::cout << point_3(target(iedge)) << std::endl;
|
||||
} else {
|
||||
if (m_verbose) std::cout << "- open moves forwards" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open moves forwards" << std::endl;
|
||||
future_point = source_p;
|
||||
// std::cout << point_3(source(iedge)) << std::endl;
|
||||
}
|
||||
|
|
@ -3267,7 +3267,7 @@ public:
|
|||
CGAL_assertion(future_direction != Vector_2());
|
||||
future_point = pinit - m_current_time * future_direction;
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.debug) {
|
||||
auto tmp = future_direction;
|
||||
tmp = KSR::normalize(tmp);
|
||||
std::cout << "- open future point: " <<
|
||||
|
|
@ -3296,32 +3296,32 @@ public:
|
|||
const auto ibbox = isegment.bbox();
|
||||
|
||||
if (has_iedge(pvertex)) {
|
||||
if (m_verbose) std::cout << "- constrained pvertex case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- constrained pvertex case" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!is_active(pvertex)) {
|
||||
if (m_verbose) std::cout << "- pvertex no active case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- pvertex no active case" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!is_active(iedge)) {
|
||||
if (m_verbose) std::cout << "- iedge no active case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- iedge no active case" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!CGAL::do_overlap(pbbox, ibbox)) {
|
||||
if (m_verbose) std::cout << "- no overlap case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- no overlap case" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
Point_2 point;
|
||||
if (!KSR::intersection(psegment, isegment, point)) {
|
||||
if (m_verbose) std::cout << "- no intersection case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- no intersection case" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m_verbose) std::cout << "- found intersection" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- found intersection" << std::endl;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -26,6 +26,8 @@
|
|||
// Internal includes.
|
||||
#include <CGAL/KSR/utils.h>
|
||||
#include <CGAL/KSR/debug.h>
|
||||
#include <CGAL/KSR/parameters.h>
|
||||
|
||||
#include <CGAL/KSR_3/Data_structure.h>
|
||||
|
||||
namespace CGAL {
|
||||
|
|
@ -100,10 +102,11 @@ private:
|
|||
using Face_handle = typename CDT::Face_handle;
|
||||
using Edge = typename CDT::Edge;
|
||||
|
||||
using Parameters = KSR::Parameters_3<FT>;
|
||||
|
||||
public:
|
||||
Finalizer(
|
||||
const bool verbose, const bool dprint, const bool debug, Data_structure& data) :
|
||||
m_verbose(verbose), m_export(dprint), m_debug(debug), m_data(data)
|
||||
Finalizer(Data_structure& data, const Parameters& parameters) :
|
||||
m_data(data), m_parameters(parameters)
|
||||
{ }
|
||||
|
||||
void clean() {
|
||||
|
|
@ -113,13 +116,13 @@ public:
|
|||
std::size_t num_hanging_pfaces = detect_hanging_pfaces(should_be_removed);
|
||||
|
||||
if (num_hanging_pfaces >= stop_value) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* number of hanging pfaces: " << num_hanging_pfaces << std::endl;
|
||||
}
|
||||
if (should_be_removed) return;
|
||||
const std::size_t num_added_pfaces = fill_holes(should_be_removed);
|
||||
CGAL_assertion(num_added_pfaces > 0);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* number of added pfaces: " << num_added_pfaces << std::endl;
|
||||
}
|
||||
num_hanging_pfaces = detect_hanging_pfaces(should_be_removed);
|
||||
|
|
@ -147,10 +150,8 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
const bool m_verbose;
|
||||
const bool m_export;
|
||||
const bool m_debug;
|
||||
Data_structure& m_data;
|
||||
const Parameters& m_parameters;
|
||||
|
||||
/*******************************
|
||||
** CLEANING **
|
||||
|
|
@ -883,7 +884,7 @@ private:
|
|||
}
|
||||
}
|
||||
}
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* found boundary volumes: "<< volume_index << std::endl;
|
||||
}
|
||||
num_volumes = volume_index;
|
||||
|
|
@ -923,7 +924,7 @@ private:
|
|||
}
|
||||
}
|
||||
const int after = volume_index;
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* found interior volumes: "<< after - before << std::endl;
|
||||
}
|
||||
num_volumes = volume_index;
|
||||
|
|
@ -960,13 +961,13 @@ private:
|
|||
for (auto& volume : volumes)
|
||||
create_cell_pvertices(volume);
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* created volumes: " << volumes.size() << std::endl;
|
||||
if (m_export) dump_volumes(m_data, "final");
|
||||
if (m_parameters.export_all) dump_volumes(m_data, "final");
|
||||
for (std::size_t i = 0; i < volumes.size(); ++i) {
|
||||
const auto& volume = volumes[i];
|
||||
CGAL_assertion(volume.pfaces.size() > 3);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout <<
|
||||
" VOLUME " << std::to_string(i) << ": "
|
||||
" pvertices: " << volume.pvertices.size() <<
|
||||
|
|
@ -1014,7 +1015,7 @@ private:
|
|||
volume_size, volume_centroid, map_volumes, queue);
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- FOUND VOLUME " << volume_index << ", (SIZE/BARYCENTER): "
|
||||
<< volume_size << " / " << volume_centroid << std::endl;
|
||||
}
|
||||
|
|
@ -1062,7 +1063,7 @@ private:
|
|||
false, query, volume_index, num_volumes, centroids,
|
||||
volume_size, volume_centroid, map_volumes, queue);
|
||||
}
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- FOUND VOLUME " << volume_index << ", (SIZE/BARYCENTER): "
|
||||
<< volume_size << " / " << volume_centroid << std::endl;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,6 +22,8 @@
|
|||
// Internal includes.
|
||||
#include <CGAL/KSR/utils.h>
|
||||
#include <CGAL/KSR/debug.h>
|
||||
#include <CGAL/KSR/parameters.h>
|
||||
|
||||
#include <CGAL/KSR_3/Data_structure.h>
|
||||
#include <CGAL/KSR_3/Polygon_splitter.h>
|
||||
|
||||
|
|
@ -55,31 +57,26 @@ private:
|
|||
using OBB_traits = CGAL::Oriented_bounding_box_traits_3<IK>;
|
||||
|
||||
using Planar_shape_type = KSR::Planar_shape_type;
|
||||
using Parameters = KSR::Parameters_3<FT>;
|
||||
|
||||
public:
|
||||
Initializer(
|
||||
const bool verbose, const bool dprint, const bool debug, Data_structure& data) :
|
||||
m_verbose(verbose), m_export(dprint), m_debug(debug), m_data(data),
|
||||
Initializer(Data_structure& data, const Parameters& parameters) :
|
||||
m_data(data), m_parameters(parameters),
|
||||
m_merge_type(Planar_shape_type::CONVEX_HULL)
|
||||
{ }
|
||||
|
||||
template<
|
||||
typename InputRange,
|
||||
typename PolygonMap>
|
||||
double initialize(
|
||||
const InputRange& input_range,
|
||||
const PolygonMap polygon_map,
|
||||
const unsigned int k,
|
||||
const double enlarge_bbox_ratio,
|
||||
const bool reorient) {
|
||||
double initialize(const InputRange& input_range, const PolygonMap polygon_map) {
|
||||
|
||||
FT time_step;
|
||||
std::array<Point_3, 8> bbox;
|
||||
create_bounding_box(
|
||||
input_range, polygon_map,
|
||||
static_cast<FT>(enlarge_bbox_ratio),
|
||||
reorient, bbox, time_step);
|
||||
if (m_verbose) {
|
||||
m_parameters.enlarge_bbox_ratio,
|
||||
m_parameters.reorient, bbox, time_step);
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* precomputed time_step: " << time_step << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -87,8 +84,8 @@ public:
|
|||
bounding_box_to_polygons(bbox, bbox_faces);
|
||||
add_polygons(input_range, polygon_map, bbox_faces);
|
||||
|
||||
if (m_verbose) std::cout << "* intersecting input polygons ... ";
|
||||
if (m_debug) {
|
||||
if (m_parameters.verbose) std::cout << "* intersecting input polygons ... ";
|
||||
if (m_parameters.debug) {
|
||||
KSR_3::dump(m_data, "init");
|
||||
// KSR_3::dump_segmented_edges(m_data, "init");
|
||||
}
|
||||
|
|
@ -96,10 +93,10 @@ public:
|
|||
CGAL_assertion(m_data.check_integrity(false));
|
||||
make_polygons_intersection_free();
|
||||
CGAL_assertion(m_data.check_integrity(false));
|
||||
set_k_intersections(k);
|
||||
set_k_intersections(m_parameters.k);
|
||||
|
||||
if (m_verbose) std::cout << "done" << std::endl;
|
||||
if (m_debug) {
|
||||
if (m_parameters.verbose) std::cout << "done" << std::endl;
|
||||
if (m_parameters.debug) {
|
||||
KSR_3::dump(m_data, "intersected");
|
||||
// KSR_3::dump_segmented_edges(m_data, "intersected");
|
||||
}
|
||||
|
|
@ -141,10 +138,8 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
const bool m_verbose;
|
||||
const bool m_export;
|
||||
const bool m_debug;
|
||||
Data_structure& m_data;
|
||||
const Parameters& m_parameters;
|
||||
const Planar_shape_type m_merge_type;
|
||||
|
||||
template<
|
||||
|
|
@ -172,12 +167,12 @@ private:
|
|||
|
||||
const auto& minp = bbox.front();
|
||||
const auto& maxp = bbox.back();
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "* bounding box minp: " << std::fixed <<
|
||||
minp.x() << "\t, " << minp.y() << "\t, " << minp.z() << std::endl;
|
||||
}
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "* bounding box maxp: " << std::fixed <<
|
||||
maxp.x() << "\t, " << maxp.y() << "\t, " << maxp.z() << std::endl;
|
||||
|
|
@ -240,12 +235,12 @@ private:
|
|||
CGAL_assertion(bbox_length_3 >= FT(0));
|
||||
const FT tol = KSR::tolerance<FT>();
|
||||
if (bbox_length_1 < tol || bbox_length_2 < tol || bbox_length_3 < tol) {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* warning: optimal bounding box is flat, reverting ..." << std::endl;
|
||||
}
|
||||
initialize_axis_aligned_box(input_range, polygon_map, bbox);
|
||||
} else {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* using optimal bounding box" << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -300,7 +295,7 @@ private:
|
|||
bbox[2] = Point_3(bbox[2].x() + d, bbox[2].y() + d, bbox[2].z() - d);
|
||||
bbox[7] = Point_3(bbox[7].x() + d, bbox[7].y() + d, bbox[7].z() + d);
|
||||
bbox[6] = Point_3(bbox[6].x() + d, bbox[6].y() - d, bbox[6].z() + d);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* setting x-based flat axis-aligned bounding box" << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -317,7 +312,7 @@ private:
|
|||
bbox[2] = Point_3(bbox[2].x() + d, bbox[2].y() + d, bbox[2].z() - d);
|
||||
bbox[7] = Point_3(bbox[7].x() + d, bbox[7].y() + d, bbox[7].z() + d);
|
||||
bbox[4] = Point_3(bbox[4].x() - d, bbox[4].y() + d, bbox[4].z() + d);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* setting y-based flat axis-aligned bounding box" << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -334,7 +329,7 @@ private:
|
|||
bbox[6] = Point_3(bbox[6].x() + d, bbox[6].y() - d, bbox[6].z() + d);
|
||||
bbox[7] = Point_3(bbox[7].x() + d, bbox[7].y() + d, bbox[7].z() + d);
|
||||
bbox[4] = Point_3(bbox[4].x() - d, bbox[4].y() + d, bbox[4].z() + d);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* setting z-based flat axis-aligned bounding box" << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -342,7 +337,7 @@ private:
|
|||
CGAL_assertion_msg(false, "ERROR: WRONG CASE!");
|
||||
}
|
||||
} else {
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* using axis-aligned bounding box" << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -433,7 +428,7 @@ private:
|
|||
CGAL_assertion(m_data.ivertices().size() == 8);
|
||||
CGAL_assertion(m_data.iedges().size() == 12);
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* inserted bbox faces: " << bbox_faces.size() << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -461,7 +456,7 @@ private:
|
|||
}
|
||||
|
||||
CGAL_assertion(m_data.number_of_support_planes() > 6);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* provided input polygons: " << input_range.size() << std::endl;
|
||||
std::cout << "* inserted input polygons: " << polygons.size() << std::endl;
|
||||
}
|
||||
|
|
@ -655,7 +650,7 @@ private:
|
|||
|
||||
void make_polygons_intersection_free() {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << std::endl;
|
||||
std::cout.precision(20);
|
||||
}
|
||||
|
|
@ -733,9 +728,9 @@ private:
|
|||
|
||||
// Refine polygons.
|
||||
for (std::size_t i = 0; i < m_data.number_of_support_planes(); ++i) {
|
||||
Polygon_splitter splitter(m_data);
|
||||
Polygon_splitter splitter(m_data, m_parameters);
|
||||
splitter.split_support_plane(i);
|
||||
// if (i >= 6 && m_export) {
|
||||
// if (i >= 6 && m_parameters.export_all) {
|
||||
// KSR_3::dump(m_data, "intersected-iter-" + std::to_string(i));
|
||||
// }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -99,12 +99,13 @@ private:
|
|||
using Uchar_map = typename Mesh_3::template Property_map<Face_index, unsigned char>;
|
||||
|
||||
using Planar_shape_type = KSR::Planar_shape_type;
|
||||
using Parameters = KSR::Parameters_3<FT>;
|
||||
|
||||
public:
|
||||
Polygon_splitter(Data_structure& data) :
|
||||
Polygon_splitter(Data_structure& data, const Parameters& parameters) :
|
||||
m_data(data),
|
||||
m_merge_type(Planar_shape_type::CONVEX_HULL),
|
||||
m_verbose(m_data.is_verbose())
|
||||
m_parameters(parameters),
|
||||
m_merge_type(Planar_shape_type::CONVEX_HULL)
|
||||
{ }
|
||||
|
||||
void split_support_plane(const std::size_t sp_idx) {
|
||||
|
|
@ -151,12 +152,13 @@ public:
|
|||
|
||||
private:
|
||||
Data_structure& m_data;
|
||||
const Parameters& m_parameters;
|
||||
|
||||
TRI m_cdt;
|
||||
std::set<PVertex> m_input;
|
||||
std::map<CID, IEdge> m_map_intersections;
|
||||
std::map<PVertex, IVertex> m_boundary_ivertices;
|
||||
const Planar_shape_type m_merge_type;
|
||||
const bool m_verbose;
|
||||
|
||||
/*******************************
|
||||
** MERGE PFACES **
|
||||
|
|
@ -856,7 +858,7 @@ private:
|
|||
}
|
||||
|
||||
CGAL_assertion(num_pfaces > 0);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "** number of newly inserted pfaces: " << num_pfaces << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -977,7 +979,7 @@ private:
|
|||
void set_boundary_ivertex(
|
||||
const PVertex& pvertex, const IVertex& ivertex) {
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "*** setting boundary ivertex " << m_data.str(ivertex) <<
|
||||
" via pvertex " << m_data.str(pvertex) << std::endl;
|
||||
|
|
@ -988,7 +990,7 @@ private:
|
|||
// Get prev and next pvertices.
|
||||
PVertex prev, next;
|
||||
std::tie(prev, next) = m_data.border_prev_and_next(pvertex);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "- prev: " << m_data.point_3(prev) << std::endl;
|
||||
std::cout << "- next: " << m_data.point_3(next) << std::endl;
|
||||
}
|
||||
|
|
@ -1055,7 +1057,7 @@ private:
|
|||
}
|
||||
|
||||
CGAL_assertion(crossed_iedges.size() >= 2);
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "- crossed " << crossed_iedges.size() << " iedges: " << std::endl;
|
||||
for (const auto& crossed_iedge : crossed_iedges) {
|
||||
std::cout << m_data.str(crossed_iedge.first) << ": " <<
|
||||
|
|
@ -1079,7 +1081,7 @@ private:
|
|||
new_pvertices.resize(crossed_iedges.size(), m_data.null_pvertex());
|
||||
|
||||
{ // first crop
|
||||
if (m_verbose) std::cout << "- first crop" << std::endl;
|
||||
if (m_parameters.verbose) std::cout << "- first crop" << std::endl;
|
||||
const auto cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
|
||||
CGAL_assertion(cropped != m_data.null_pvertex());
|
||||
|
||||
|
|
@ -1093,12 +1095,12 @@ private:
|
|||
CGAL_assertion(future_directions.front() != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_points.front());
|
||||
m_data.direction(cropped) = future_directions.front();
|
||||
if (m_verbose) std::cout << "- cropped 1: " <<
|
||||
if (m_parameters.verbose) std::cout << "- cropped 1: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
}
|
||||
|
||||
{ // second crop
|
||||
if (m_verbose) std::cout << "- second crop" << std::endl;
|
||||
if (m_parameters.verbose) std::cout << "- second crop" << std::endl;
|
||||
const auto cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, prev.second));
|
||||
CGAL_assertion(cropped != m_data.null_pvertex());
|
||||
|
||||
|
|
@ -1112,7 +1114,7 @@ private:
|
|||
CGAL_assertion(future_directions.back() != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_points.back());
|
||||
m_data.direction(cropped) = future_directions.back();
|
||||
if (m_verbose) std::cout << "- cropped 2: " <<
|
||||
if (m_parameters.verbose) std::cout << "- cropped 2: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1217,11 +1219,8 @@ private:
|
|||
m_data.point_2(sp_idx, m_data.target(iedge))) >= KSR::point_tolerance<FT>(),
|
||||
"TODO: SET FUTURE DIRECTION, HANDLE ZERO-LENGTH IEDGE!");
|
||||
|
||||
const bool is_debug = false;
|
||||
m_data.set_verbose(is_debug);
|
||||
const auto is_parallel = m_data.compute_future_point_and_direction(
|
||||
pvertex, ivertex, n1, n2, iedge, future_point, future_direction);
|
||||
m_data.set_verbose(m_verbose);
|
||||
|
||||
CGAL_assertion_msg(!is_parallel,
|
||||
"TODO: COMPUTE FUTURE POINT AND DIRECTION, ADD PARALLEL CASE!");
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@
|
|||
// Internal includes.
|
||||
#include <CGAL/KSR/utils.h>
|
||||
#include <CGAL/KSR/debug.h>
|
||||
#include <CGAL/KSR/parameters.h>
|
||||
|
||||
#include <CGAL/KSR_3/Event.h>
|
||||
#include <CGAL/KSR_3/Event_queue.h>
|
||||
#include <CGAL/KSR_3/Data_structure.h>
|
||||
|
|
@ -53,12 +55,12 @@ private:
|
|||
|
||||
using Bbox_2 = CGAL::Bbox_2;
|
||||
using Face_index = typename Data_structure::Face_index;
|
||||
using Parameters = KSR::Parameters_3<FT>;
|
||||
|
||||
public:
|
||||
Propagation(
|
||||
const bool verbose, const bool dprint, const bool debug, Data_structure& data) :
|
||||
m_verbose(verbose), m_export(dprint), m_debug(debug), m_data(data),
|
||||
m_queue(m_debug), m_min_time(-FT(1)), m_max_time(-FT(1))
|
||||
Propagation(Data_structure& data, const Parameters& parameters) :
|
||||
m_data(data), m_parameters(parameters), m_queue(parameters.debug),
|
||||
m_min_time(-FT(1)), m_max_time(-FT(1))
|
||||
{ }
|
||||
|
||||
const std::pair<std::size_t, std::size_t> propagate(const FT time_step) {
|
||||
|
|
@ -76,7 +78,7 @@ public:
|
|||
CGAL_assertion(m_data.check_integrity());
|
||||
++num_queue_calls;
|
||||
|
||||
if (m_verbose && !m_debug) {
|
||||
if (m_parameters.verbose && !m_parameters.debug) {
|
||||
if ((num_queue_calls % 50) == 0) {
|
||||
std::cout << ".................................................." << std::endl;
|
||||
}
|
||||
|
|
@ -97,10 +99,9 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
const bool m_verbose;
|
||||
const bool m_export;
|
||||
const bool m_debug;
|
||||
Data_structure& m_data;
|
||||
const Parameters& m_parameters;
|
||||
|
||||
Event_queue m_queue;
|
||||
FT m_min_time;
|
||||
FT m_max_time;
|
||||
|
|
@ -111,7 +112,7 @@ private:
|
|||
|
||||
bool initialize_queue() {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "* initializing queue for events in [" <<
|
||||
m_min_time << ";" << m_max_time << "]" << std::endl;
|
||||
}
|
||||
|
|
@ -516,7 +517,7 @@ private:
|
|||
std::size_t run(
|
||||
const std::size_t initial_iteration) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "* unstacking queue, current size: " << m_queue.size() << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -528,7 +529,7 @@ private:
|
|||
const FT current_time = event.time();
|
||||
|
||||
// const std::size_t sp_debug_idx = 20;
|
||||
if (m_export /* && event.pvertex().first == sp_debug_idx */) {
|
||||
if (m_parameters.export_all /* && event.pvertex().first == sp_debug_idx */) {
|
||||
if (iteration < 10) {
|
||||
dump(m_data, "iter-0" + std::to_string(iteration));
|
||||
// dump_2d_surface_mesh(m_data, sp_debug_idx, "iter-" + std::to_string(iteration) +
|
||||
|
|
@ -545,7 +546,7 @@ private:
|
|||
}
|
||||
|
||||
m_data.update_positions(current_time);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << std::endl << "* APPLYING " << iteration << ": " << event << std::endl;
|
||||
}
|
||||
++iteration;
|
||||
|
|
@ -626,7 +627,7 @@ private:
|
|||
const PVertex& /* pother */,
|
||||
const Event& /* event */) {
|
||||
|
||||
// if (m_debug) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "WARNING: SKIPPING TWO UNCONSTRAINED PVERTICES MEET EVENT!" << std::endl;
|
||||
// std::cout << "WARNING: THIS EVENT IS DUST!" << std::endl;
|
||||
// m_queue.print();
|
||||
|
|
@ -644,7 +645,7 @@ private:
|
|||
const PVertex& /* pother */,
|
||||
const Event& /* event */) {
|
||||
|
||||
// if (m_debug) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "WARNING: SKIPPING TWO CONSTRAINED PVERTICES MEET EVENT!" << std::endl;
|
||||
// std::cout << "WARNING: THIS EVENT IS DUST!" << std::endl;
|
||||
// m_queue.print();
|
||||
|
|
@ -662,7 +663,7 @@ private:
|
|||
const IEdge& /* iedge */,
|
||||
const Event& /* event */) {
|
||||
|
||||
// if (m_debug) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "WARNING: SKIPPING CONSTRAINED PVERTEX MEETS IEDGE EVENT!" << std::endl;
|
||||
// std::cout << "WARNING: THIS EVENT IS DUST!" << std::endl;
|
||||
// // m_queue.print();
|
||||
|
|
@ -688,7 +689,7 @@ private:
|
|||
CGAL_assertion( m_data.has_iedge(pvertex));
|
||||
CGAL_assertion(!m_data.has_iedge(pother));
|
||||
|
||||
// if (m_debug) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "WARNING: SKIPPING PVERTICES MEET IVERTEX EVENT!" << std::endl;
|
||||
// std::cout << "WARNING: THIS EVENT IS DUST!" << std::endl;
|
||||
// m_queue.print();
|
||||
|
|
@ -707,7 +708,7 @@ private:
|
|||
CGAL_assertion(!m_data.has_iedge(pvertex));
|
||||
CGAL_assertion( m_data.has_one_pface(pvertex));
|
||||
|
||||
// if (m_debug) {
|
||||
// if (m_parameters.debug) {
|
||||
// std::cout << "WARNING: SKIPPING UNCONSTRAINED PVERTEX MEETS IVERTEX EVENT!" << std::endl;
|
||||
// std::cout << "WARNING: THIS EVENT IS DUST!" << std::endl;
|
||||
// m_queue.print();
|
||||
|
|
@ -913,7 +914,7 @@ private:
|
|||
bool check_pvertex_meets_iedge_global_k(
|
||||
const PVertex& pvertex, const IEdge& iedge) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- k intersections before: " << m_data.k(pvertex.first) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -921,7 +922,7 @@ private:
|
|||
std::tie(is_occupied_iedge, is_bbox_reached) = m_data.collision_occured(pvertex, iedge);
|
||||
const bool is_limit_line = m_data.update_limit_lines_and_k(pvertex, iedge, is_occupied_iedge);
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- bbox: " << is_bbox_reached << "; " <<
|
||||
" limit: " << is_limit_line << "; " <<
|
||||
" occupied: " << is_occupied_iedge << std::endl;
|
||||
|
|
@ -929,17 +930,17 @@ private:
|
|||
|
||||
bool stop = false;
|
||||
if (is_bbox_reached) {
|
||||
if (m_debug) std::cout << "- bbox, stop" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- bbox, stop" << std::endl;
|
||||
stop = true;
|
||||
} else if (is_limit_line) {
|
||||
if (m_debug) std::cout << "- limit, stop" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- limit, stop" << std::endl;
|
||||
stop = true;
|
||||
} else {
|
||||
if (m_debug) std::cout << "- free, any k, continue" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- free, any k, continue" << std::endl;
|
||||
stop = false;
|
||||
}
|
||||
CGAL_assertion(m_data.k(pvertex.first) >= 1);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- k intersections after: " << m_data.k(pvertex.first) << std::endl;
|
||||
}
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK PVERTEX MEETS IVERTEX GLOBAL!");
|
||||
|
|
@ -954,7 +955,7 @@ private:
|
|||
bool check_pedge_meets_iedge_global_k(
|
||||
const PVertex& pvertex, const PVertex& pother, const IEdge& iedge) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- k intersections before: " << m_data.k(pvertex.first) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -966,7 +967,7 @@ private:
|
|||
const bool is_limit_line_1 = m_data.update_limit_lines_and_k(pvertex, iedge, is_occupied_iedge_1);
|
||||
const bool is_limit_line_2 = m_data.update_limit_lines_and_k(pother , iedge, is_occupied_iedge_2);
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- bbox1: " << is_bbox_reached_1 << "; " <<
|
||||
" limit1: " << is_limit_line_1 << "; " <<
|
||||
" occupied1: " << is_occupied_iedge_1 << std::endl;
|
||||
|
|
@ -979,19 +980,19 @@ private:
|
|||
|
||||
bool stop = false;
|
||||
if (is_bbox_reached_1 || is_bbox_reached_2) {
|
||||
if (m_debug) std::cout << "- bbox, stop" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- bbox, stop" << std::endl;
|
||||
stop = true;
|
||||
} else if (is_limit_line_1 || is_limit_line_2) {
|
||||
if (m_debug) std::cout << "- limit, stop" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- limit, stop" << std::endl;
|
||||
stop = true;
|
||||
} else {
|
||||
if (m_debug) std::cout << "- free, any k, continue" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- free, any k, continue" << std::endl;
|
||||
CGAL_assertion(!m_data.is_sneaking_pedge(pvertex, pother, iedge));
|
||||
stop = false;
|
||||
}
|
||||
|
||||
CGAL_assertion(m_data.k(pvertex.first) >= 1);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- k intersections after: " << m_data.k(pvertex.first) << std::endl;
|
||||
}
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK PEDGE MEETS IEDGE GLOBAL!");
|
||||
|
|
@ -1052,7 +1053,7 @@ private:
|
|||
PVertex crop_pvertex_along_iedge(
|
||||
const PVertex& pvertex, const IEdge& iedge) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "** cropping " << m_data.str(pvertex) << " along " << m_data.str(iedge) << std::endl;
|
||||
std::cout << "- pvertex: " << m_data.point_3(pvertex) << std::endl;
|
||||
|
|
@ -1078,7 +1079,7 @@ private:
|
|||
CGAL_assertion(future_direction_a != Vector_2());
|
||||
CGAL_assertion(future_direction_b != Vector_2());
|
||||
if (is_parallel_a || is_parallel_b) {
|
||||
if (m_debug) std::cout << "- pvertex to iedge, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- pvertex to iedge, parallel case" << std::endl;
|
||||
// CGAL_assertion_msg(!is_parallel_a && !is_parallel_b,
|
||||
// "TODO: PVERTEX -> IEDGE, HANDLE CASE WITH PARALLEL LINES!");
|
||||
}
|
||||
|
|
@ -1086,7 +1087,7 @@ private:
|
|||
const PEdge pedge(pvertex.first, m_data.support_plane(pvertex).split_vertex(pvertex.second));
|
||||
CGAL_assertion(m_data.source(pedge) == pvertex || m_data.target(pedge) == pvertex);
|
||||
const PVertex pother = m_data.opposite(pedge, pvertex);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- new pedge: " << m_data.str(pedge) << " between "
|
||||
<< m_data.str(pvertex) << " and " << m_data.str(pother) << std::endl;
|
||||
}
|
||||
|
|
@ -1100,7 +1101,7 @@ private:
|
|||
m_data.direction(pvertex) = future_direction_a;
|
||||
m_data.direction(pother) = future_direction_b;
|
||||
|
||||
if (m_debug) std::cout << "- new pvertices: " <<
|
||||
if (m_parameters.debug) std::cout << "- new pvertices: " <<
|
||||
m_data.str(pother) << ": " << m_data.point_3(pother) << std::endl;
|
||||
|
||||
// CGAL_assertion_msg(false, "TODO: CROP PVERTEX ALONG IEDGE!");
|
||||
|
|
@ -1110,7 +1111,7 @@ private:
|
|||
std::array<PVertex, 3> propagate_pvertex_beyond_iedge(
|
||||
const PVertex& pvertex, const IEdge& iedge) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "** propagating " << m_data.str(pvertex) << " beyond " << m_data.str(iedge) << std::endl;
|
||||
std::cout << "- pvertex: " << m_data.point_3(pvertex) << std::endl;
|
||||
|
|
@ -1124,7 +1125,7 @@ private:
|
|||
const PVertex propagated = m_data.add_pvertex(pvertex.first, original_point);
|
||||
m_data.direction(propagated) = original_direction;
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- propagated: " << m_data.str(propagated) << ": " << m_data.point_3(propagated) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1136,7 +1137,7 @@ private:
|
|||
const PFace new_pface = m_data.add_pface(pvertices);
|
||||
CGAL_assertion(new_pface != m_data.null_pface());
|
||||
CGAL_assertion(new_pface.second != Face_index());
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- new pface " << m_data.str(new_pface) << ": " <<
|
||||
m_data.centroid_of_pface(new_pface) << std::endl;
|
||||
}
|
||||
|
|
@ -1148,7 +1149,7 @@ private:
|
|||
void crop_pedge_along_iedge(
|
||||
const PVertex& pvertex, const PVertex& pother, const IEdge& iedge) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "** cropping pedge [" << m_data.str(pvertex) << "-" << m_data.str(pother)
|
||||
<< "] along " << m_data.str(iedge) << std::endl;
|
||||
|
|
@ -1168,7 +1169,7 @@ private:
|
|||
const PVertex prev(pvertex.first, m_data.support_plane(pvertex).prev(pvertex.second));
|
||||
const PVertex next(pvertex.first, m_data.support_plane(pvertex).next(pvertex.second));
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- prev pv: " << m_data.point_3(prev) << std::endl;
|
||||
std::cout << "- next pv: " << m_data.point_3(next) << std::endl;
|
||||
}
|
||||
|
|
@ -1182,7 +1183,7 @@ private:
|
|||
}
|
||||
CGAL_assertion(pthird != m_data.null_pvertex());
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- pthird pv: " << m_data.point_3(pthird) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1190,7 +1191,7 @@ private:
|
|||
0, IVertex(), pvertex, pthird, iedge, future_point, future_direction);
|
||||
CGAL_assertion(future_direction != Vector_2());
|
||||
if (is_parallel) {
|
||||
if (m_debug) std::cout << "- pedge to iedge 1, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- pedge to iedge 1, parallel case" << std::endl;
|
||||
// CGAL_assertion_msg(!is_parallel,
|
||||
// "TODO: PEDGE -> IEDGE 1, HANDLE CASE WITH PARALLEL LINES!");
|
||||
}
|
||||
|
|
@ -1204,7 +1205,7 @@ private:
|
|||
const PVertex prev(pother.first, m_data.support_plane(pother).prev(pother.second));
|
||||
const PVertex next(pother.first, m_data.support_plane(pother).next(pother.second));
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- prev po: " << m_data.point_3(prev) << std::endl;
|
||||
std::cout << "- next po: " << m_data.point_3(next) << std::endl;
|
||||
}
|
||||
|
|
@ -1218,7 +1219,7 @@ private:
|
|||
}
|
||||
CGAL_assertion(pthird != m_data.null_pvertex());
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- pthird po: " << m_data.point_3(pthird) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1226,7 +1227,7 @@ private:
|
|||
0, IVertex(), pother, pthird, iedge, future_point, future_direction);
|
||||
CGAL_assertion(future_direction != Vector_2());
|
||||
if (is_parallel) {
|
||||
if (m_debug) std::cout << "- pedge to iedge 2, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- pedge to iedge 2, parallel case" << std::endl;
|
||||
// CGAL_assertion_msg(!is_parallel,
|
||||
// "TODO: PEDGE -> IEDGE 2, HANDLE CASE WITH PARALLEL LINES!");
|
||||
}
|
||||
|
|
@ -1245,7 +1246,7 @@ private:
|
|||
std::pair<PVertex, PVertex> propagate_pedge_beyond_iedge(
|
||||
const PVertex& pvertex, const PVertex& pother, const IEdge& iedge) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "** propagating pedge [" << m_data.str(pvertex) << "-" << m_data.str(pother)
|
||||
<< "] beyond " << m_data.str(iedge) << std::endl;
|
||||
|
|
@ -1268,7 +1269,7 @@ private:
|
|||
const PVertex propagated_2 = m_data.add_pvertex(pother.first, original_point_2);
|
||||
m_data.direction(propagated_2) = original_direction_2;
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- propagated 1: " << m_data.str(propagated_1) << ": " <<
|
||||
m_data.point_3(propagated_1) << std::endl;
|
||||
std::cout << "- propagated 2: " << m_data.str(propagated_2) << ": " <<
|
||||
|
|
@ -1284,7 +1285,7 @@ private:
|
|||
const PFace new_pface = m_data.add_pface(pvertices);
|
||||
CGAL_assertion(new_pface != m_data.null_pface());
|
||||
CGAL_assertion(new_pface.second != Face_index());
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- new pface " << m_data.str(new_pface) << ": " << m_data.centroid_of_pface(new_pface) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1295,7 +1296,7 @@ private:
|
|||
bool transfer_pvertex_via_iedge(
|
||||
const PVertex& pvertex, const PVertex& pother) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
CGAL_assertion(m_data.has_iedge(pvertex));
|
||||
std::cout << "** transfering " << m_data.str(pother) << " through " << m_data.str(pvertex) << " via "
|
||||
|
|
@ -1310,12 +1311,12 @@ private:
|
|||
std::tie(source_pface, target_pface) = m_data.pfaces_of_pvertex(pvertex);
|
||||
const auto common_pface = m_data.pface_of_pvertex(pother);
|
||||
if (common_pface == target_pface) {
|
||||
if (m_debug) std::cout << "- swap pfaces" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- swap pfaces" << std::endl;
|
||||
std::swap(source_pface, target_pface);
|
||||
}
|
||||
CGAL_assertion(common_pface == source_pface);
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- initial pfaces: " << std::endl;
|
||||
if (source_pface != m_data.null_pface()) {
|
||||
std::cout << "source " << m_data.str(source_pface) << ": " <<
|
||||
|
|
@ -1330,7 +1331,7 @@ private:
|
|||
// Get pthird.
|
||||
PVertex pthird = m_data.next(pother);
|
||||
if (pthird == pvertex) pthird = m_data.prev(pother);
|
||||
if (m_debug) std::cout << "- pthird: " << m_data.point_3(pthird) << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- pthird: " << m_data.point_3(pthird) << std::endl;
|
||||
|
||||
// Get future point and direction.
|
||||
CGAL_assertion(m_data.has_iedge(pvertex));
|
||||
|
|
@ -1348,7 +1349,7 @@ private:
|
|||
0, IVertex(), pother, pthird, iedge, future_point, future_direction);
|
||||
CGAL_assertion(future_direction != Vector_2());
|
||||
if (is_parallel) {
|
||||
if (m_debug) std::cout << "- transfer pvertex, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- transfer pvertex, parallel case" << std::endl;
|
||||
// CGAL_assertion_msg(!is_parallel,
|
||||
// "TODO: TRANSFER PVERTEX, HANDLE CASE WITH PARALLEL LINES!");
|
||||
}
|
||||
|
|
@ -1381,11 +1382,11 @@ private:
|
|||
CGAL_assertion(m_data.mesh(pedge).face(he) == common_pface.second);
|
||||
|
||||
if (m_data.mesh(pedge).target(he) == pvertex.second) {
|
||||
// if (m_debug) std::cout << "- shifting target" << std::endl;
|
||||
// if (m_parameters.debug) std::cout << "- shifting target" << std::endl;
|
||||
CGAL::Euler::shift_target(he, m_data.mesh(pedge));
|
||||
} else {
|
||||
CGAL_assertion(m_data.mesh(pedge).source(he) == pvertex.second);
|
||||
// if (m_debug) std::cout << "- shifting source" << std::endl;
|
||||
// if (m_parameters.debug) std::cout << "- shifting source" << std::endl;
|
||||
CGAL::Euler::shift_source(he, m_data.mesh(pedge));
|
||||
}
|
||||
|
||||
|
|
@ -1403,7 +1404,7 @@ private:
|
|||
// "TODO: TRANSFER PVERTEX 2, ADD NEW FUTURE POINTS AND DIRECTIONS!");
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- new pfaces: " << std::endl;
|
||||
if (source_pface != m_data.null_pface()) {
|
||||
std::cout << "source " << m_data.str(source_pface) << ": " <<
|
||||
|
|
@ -1424,7 +1425,7 @@ private:
|
|||
const PVertex& event_pvertex, const std::vector<PVertex>& pvertices,
|
||||
std::vector< std::pair<IEdge, bool> >& crossed_iedges) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "** merging " << m_data.str(pvertices[1]) << " on " << m_data.str(ivertex) << std::endl;
|
||||
std::cout << "- pvertex: " << m_data.point_3(pvertices[1]) << std::endl;
|
||||
|
|
@ -1437,7 +1438,7 @@ private:
|
|||
const PVertex next = pvertices.back();
|
||||
const PVertex pvertex = pvertices[1];
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
const auto iedge = m_data.iedge(pvertex);
|
||||
if (iedge != m_data.null_iedge()) {
|
||||
std::cout << "- start from: " << m_data.str(iedge) << " " <<
|
||||
|
|
@ -1460,7 +1461,7 @@ private:
|
|||
CGAL_assertion_msg(false, "ERROR: INVALID CONNECTIVITY CASE!");
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- found neighbors: " << std::endl <<
|
||||
"prev = " << m_data.point_3(prev) << std::endl <<
|
||||
"fron = " << m_data.point_3(front) << std::endl <<
|
||||
|
|
@ -1483,7 +1484,7 @@ private:
|
|||
m_data.support_plane(curr).set_point(curr.second, ipoint);
|
||||
}
|
||||
m_data.connect(pvertex, ivertex);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- frozen pvertex: " << m_data.str(pvertex) << " : " << m_data.point_3(pvertex) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1517,11 +1518,11 @@ private:
|
|||
}
|
||||
|
||||
if (back_constrained && !front_constrained) {
|
||||
if (m_debug) std::cout << "- reverse iedges" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- reverse iedges" << std::endl;
|
||||
std::reverse(iedges.begin(), iedges.end());
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- initial iedges: " << iedges.size() << std::endl;
|
||||
for (const auto& iedge : iedges) {
|
||||
std::cout << m_data.str(iedge.first) << ": " <<
|
||||
|
|
@ -1561,7 +1562,7 @@ private:
|
|||
crossed_iedges.push_back(std::make_pair(m_data.iedge(pvertex), true));
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::size_t num_new_pvertices = 0;
|
||||
for (const auto& new_pvertex : new_pvertices) {
|
||||
if (new_pvertex != m_data.null_pvertex()) ++num_new_pvertices;
|
||||
|
|
@ -1576,7 +1577,7 @@ private:
|
|||
|
||||
void apply_closing_case(const PVertex& pvertex) const {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "*** CLOSING CASE" << std::endl;
|
||||
}
|
||||
|
|
@ -1595,7 +1596,7 @@ private:
|
|||
std::vector< std::pair<IEdge, bool> >& crossed_iedges,
|
||||
std::vector<PVertex>& new_pvertices) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "*** BACK BORDER CASE" << std::endl;
|
||||
}
|
||||
|
|
@ -1630,7 +1631,7 @@ private:
|
|||
Point_2 shifted_prev;
|
||||
const auto pp_curr = m_data.point_2(prev, curr_time);
|
||||
if (prev_diff < tol) {
|
||||
if (m_debug) std::cout << "- back, same time events, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back, same time events, prev" << std::endl;
|
||||
CGAL_assertion(CGAL::abs(ntime - curr_time) >= tol);
|
||||
const auto pp_futr = m_data.point_2(prev, ntime);
|
||||
const auto dirp = Vector_2(pp_curr, pp_futr);
|
||||
|
|
@ -1647,28 +1648,28 @@ private:
|
|||
// std::cout << "fiedge: " << (fiedges.size() > 0) << std::endl;
|
||||
// std::cout << "fiedge: " << m_data.segment_3(fiedges.back()) << std::endl;
|
||||
if (fiedges.size() > 0 && iedge == fiedges.back()) {
|
||||
if (m_debug) std::cout << "- found same time iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- found same time iedge, prev" << std::endl;
|
||||
found_iedge = true; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found_iedge) {
|
||||
shifted_prev = pp_curr + dirp / FT(2);
|
||||
if (m_debug) std::cout << "- excluding iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- excluding iedge, prev" << std::endl;
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK BACK PREV CASE 1!");
|
||||
} else {
|
||||
shifted_prev = pp_curr - dirp / FT(2);
|
||||
if (m_debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK BACK PREV CASE 2!");
|
||||
}
|
||||
} else {
|
||||
const auto pp_last = m_data.point_2(prev, prev_time);
|
||||
const auto dirp = Vector_2(pp_last, pp_curr);
|
||||
shifted_prev = pp_curr - dirp / FT(10);
|
||||
if (m_debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- shifting prev: " << m_data.to_3d(pvertex.first, shifted_prev) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1702,7 +1703,7 @@ private:
|
|||
|
||||
const bool is_bbox_reached = ( m_data.collision_occured(pvertex, iedge) ).second;
|
||||
const bool is_limit_reached = ( m_data.line_idx(iedge) == other_side_limit );
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- bbox: " << is_bbox_reached << "; limit: " << is_limit_reached << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1718,7 +1719,7 @@ private:
|
|||
}
|
||||
|
||||
CGAL_assertion(crossed_iedges.size() > 0);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- crossed " << crossed_iedges.size() << " iedges: " << std::endl;
|
||||
for (const auto& crossed_iedge : crossed_iedges) {
|
||||
std::cout << m_data.str(crossed_iedge.first) << ": " <<
|
||||
|
|
@ -1740,12 +1741,12 @@ private:
|
|||
if (KSR::distance(m_data.point_2(back), m_data.point_2(prev)) < KSR::point_tolerance<FT>()) {
|
||||
// is_parallel = m_data.compute_future_point_and_direction(
|
||||
// 0, back, prev, iedge_0, future_point, future_direction); // does not work!
|
||||
if (m_debug) std::cout << "- back = prev, equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back = prev, equal points case" << std::endl;
|
||||
is_parallel = m_data.compute_future_point_and_direction(
|
||||
0, ivertex, event_pvertex, prev, iedge_0, future_point, future_direction);
|
||||
// CGAL_assertion_msg(false, "TODO: BACK, FIX CASE WITH EQUAL BACK AND PREV!");
|
||||
} else {
|
||||
if (m_debug) std::cout << "- back, prev, not equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back, prev, not equal points case" << std::endl;
|
||||
is_parallel = m_data.compute_future_point_and_direction(
|
||||
0, ivertex, back, prev, iedge_0, future_point, future_direction);
|
||||
}
|
||||
|
|
@ -1763,7 +1764,7 @@ private:
|
|||
{ // crop
|
||||
PVertex cropped = m_data.null_pvertex();
|
||||
if (prev_iedge == iedge_0) {
|
||||
if (m_debug) std::cout << "- back, prev, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back, prev, parallel case" << std::endl;
|
||||
|
||||
// In case, we are parallel, we update the future point and direction.
|
||||
cropped = prev;
|
||||
|
|
@ -1772,7 +1773,7 @@ private:
|
|||
0, ivertex, prev, pprev, prev_iedge, future_point, future_direction);
|
||||
|
||||
} else {
|
||||
if (m_debug) std::cout << "- back, prev, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- back, prev, standard case" << std::endl;
|
||||
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, prev.second));
|
||||
}
|
||||
|
||||
|
|
@ -1789,7 +1790,7 @@ private:
|
|||
CGAL_assertion(future_direction != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_point);
|
||||
m_data.direction(cropped) = future_direction;
|
||||
if (m_debug) std::cout << "- cropped: " <<
|
||||
if (m_parameters.debug) std::cout << "- cropped: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
CGAL_assertion(m_data.is_correctly_oriented(
|
||||
cropped.first, future_direction, ivertex, iedge_0));
|
||||
|
|
@ -1813,7 +1814,7 @@ private:
|
|||
std::vector< std::pair<IEdge, bool> >& crossed_iedges,
|
||||
std::vector<PVertex>& new_pvertices) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "*** FRONT BORDER CASE" << std::endl;
|
||||
}
|
||||
|
|
@ -1848,7 +1849,7 @@ private:
|
|||
Point_2 shifted_next;
|
||||
const auto pn_curr = m_data.point_2(next, curr_time);
|
||||
if (next_diff < tol) {
|
||||
if (m_debug) std::cout << "- front, same time events, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front, same time events, next" << std::endl;
|
||||
CGAL_assertion(CGAL::abs(ntime - curr_time) >= tol);
|
||||
const auto pn_futr = m_data.point_2(next, ntime);
|
||||
const auto dirn = Vector_2(pn_curr, pn_futr);
|
||||
|
|
@ -1864,28 +1865,28 @@ private:
|
|||
// std::cout << "biedge: " << (biedges.size() > 0) << std::endl;
|
||||
// std::cout << "biedge: " << m_data.segment_3(biedges.front()) << std::endl;
|
||||
if (biedges.size() > 0 && iedge == biedges.front()) {
|
||||
if (m_debug) std::cout << "- found same time iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- found same time iedge, next" << std::endl;
|
||||
found_iedge = true; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found_iedge) {
|
||||
shifted_next = pn_curr + dirn / FT(2);
|
||||
if (m_debug) std::cout << "- excluding iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- excluding iedge, next" << std::endl;
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK FRONT NEXT CASE 1!");
|
||||
} else {
|
||||
shifted_next = pn_curr - dirn / FT(2);
|
||||
if (m_debug) std::cout << "- including iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, next" << std::endl;
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK FRONT NEXT CASE 2!");
|
||||
}
|
||||
} else {
|
||||
const auto pn_last = m_data.point_2(next, next_time);
|
||||
const auto dirn = Vector_2(pn_last, pn_curr);
|
||||
shifted_next = pn_curr - dirn / FT(10);
|
||||
if (m_debug) std::cout << "- including iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, next" << std::endl;
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- shifting next: " << m_data.to_3d(pvertex.first, shifted_next) << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1919,7 +1920,7 @@ private:
|
|||
|
||||
const bool is_bbox_reached = ( m_data.collision_occured(pvertex, iedge) ).second;
|
||||
const bool is_limit_reached = ( m_data.line_idx(iedge) == other_side_limit );
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- bbox: " << is_bbox_reached << "; limit: " << is_limit_reached << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -1935,7 +1936,7 @@ private:
|
|||
}
|
||||
|
||||
CGAL_assertion(crossed_iedges.size() > 0);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- crossed " << crossed_iedges.size() << " iedges: " << std::endl;
|
||||
for (const auto& crossed_iedge : crossed_iedges) {
|
||||
std::cout << m_data.str(crossed_iedge.first) << ": " <<
|
||||
|
|
@ -1955,11 +1956,11 @@ private:
|
|||
{ // future point and direction
|
||||
bool is_parallel = false;
|
||||
if (KSR::distance(m_data.point_2(front), m_data.point_2(next)) < KSR::point_tolerance<FT>()) {
|
||||
if (m_debug) std::cout << "- front = next, equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front = next, equal points case" << std::endl;
|
||||
CGAL_assertion_msg(false,
|
||||
"TODO: FRONT, FIX CASE WITH EQUAL FRONT AND NEXT! SEE BACK CASE FOR REFERENCE!");
|
||||
} else {
|
||||
if (m_debug) std::cout << "- front, next, not equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front, next, not equal points case" << std::endl;
|
||||
is_parallel = m_data.compute_future_point_and_direction(
|
||||
0, ivertex, front, next, iedge_0, future_point, future_direction);
|
||||
}
|
||||
|
|
@ -1977,7 +1978,7 @@ private:
|
|||
{ // crop
|
||||
PVertex cropped = m_data.null_pvertex();
|
||||
if (next_iedge == iedge_0) {
|
||||
if (m_debug) std::cout << "- front, next, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front, next, parallel case" << std::endl;
|
||||
|
||||
// In case, we are parallel, we update the future point and direction.
|
||||
cropped = next;
|
||||
|
|
@ -1986,7 +1987,7 @@ private:
|
|||
0, ivertex, next, nnext, next_iedge, future_point, future_direction);
|
||||
|
||||
} else {
|
||||
if (m_debug) std::cout << "- front, next, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- front, next, standard case" << std::endl;
|
||||
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
|
||||
}
|
||||
|
||||
|
|
@ -2003,7 +2004,7 @@ private:
|
|||
CGAL_assertion(future_direction != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_point);
|
||||
m_data.direction(cropped) = future_direction;
|
||||
if (m_debug) std::cout << "- cropped: " <<
|
||||
if (m_parameters.debug) std::cout << "- cropped: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
CGAL_assertion(m_data.is_correctly_oriented(
|
||||
cropped.first, future_direction, ivertex, iedge_0));
|
||||
|
|
@ -2029,7 +2030,7 @@ private:
|
|||
std::vector< std::pair<IEdge, bool> >& crossed_iedges,
|
||||
std::vector<PVertex>& new_pvertices) {
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout.precision(20);
|
||||
std::cout << "*** OPEN CASE" << std::endl;
|
||||
}
|
||||
|
|
@ -2069,7 +2070,7 @@ private:
|
|||
Point_2 shifted_prev;
|
||||
const auto pp_curr = m_data.point_2(prev, curr_time);
|
||||
if (prev_diff < tol) {
|
||||
if (m_debug) std::cout << "- open, same time events, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, same time events, prev" << std::endl;
|
||||
CGAL_assertion(CGAL::abs(ntime - curr_time) >= tol);
|
||||
const auto pp_futr = m_data.point_2(prev, ntime);
|
||||
const auto dirp = Vector_2(pp_curr, pp_futr);
|
||||
|
|
@ -2085,31 +2086,31 @@ private:
|
|||
// std::cout << "fiedge: " << (fiedges.size() > 0) << std::endl;
|
||||
// std::cout << "fiedge: " << m_data.segment_3(fiedges.back()) << std::endl;
|
||||
if (fiedges.size() > 0 && iedge == fiedges.back()) {
|
||||
if (m_debug) std::cout << "- found same time iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- found same time iedge, prev" << std::endl;
|
||||
found_iedge = true; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found_iedge) {
|
||||
shifted_prev = pp_curr + dirp / FT(2);
|
||||
if (m_debug) std::cout << "- excluding iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- excluding iedge, prev" << std::endl;
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK OPEN PREV CASE 1!");
|
||||
} else {
|
||||
shifted_prev = pp_curr - dirp / FT(2);
|
||||
if (m_debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
CGAL_assertion_msg(false, "TODO: CHECK OPEN PREV CASE 2!");
|
||||
}
|
||||
} else {
|
||||
const auto pp_last = m_data.point_2(prev, prev_time);
|
||||
const auto dirp = Vector_2(pp_last, pp_curr);
|
||||
shifted_prev = pp_curr - dirp / FT(10);
|
||||
if (m_debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, prev" << std::endl;
|
||||
}
|
||||
|
||||
Point_2 shifted_next;
|
||||
const auto pn_curr = m_data.point_2(next, curr_time);
|
||||
if (next_diff < tol) {
|
||||
if (m_debug) std::cout << "- open, same time events, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, same time events, next" << std::endl;
|
||||
CGAL_assertion(CGAL::abs(ntime - curr_time) >= tol);
|
||||
const auto pn_futr = m_data.point_2(next, ntime);
|
||||
const auto dirn = Vector_2(pn_curr, pn_futr);
|
||||
|
|
@ -2125,28 +2126,28 @@ private:
|
|||
// std::cout << "biedge: " << (biedges.size() > 0) << std::endl;
|
||||
// std::cout << "biedge: " << m_data.segment_3(biedges.front()) << std::endl;
|
||||
if (biedges.size() > 0 && iedge == biedges.front()) {
|
||||
if (m_debug) std::cout << "- found same time iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- found same time iedge, next" << std::endl;
|
||||
found_iedge = true; break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found_iedge) {
|
||||
shifted_next = pn_curr + dirn / FT(2);
|
||||
if (m_debug) std::cout << "- excluding iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- excluding iedge, next" << std::endl;
|
||||
// CGAL_assertion_msg(false, "TODO: CHECK OPEN NEXT CASE 1!");
|
||||
} else {
|
||||
shifted_next = pn_curr - dirn / FT(2);
|
||||
if (m_debug) std::cout << "- including iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, next" << std::endl;
|
||||
CGAL_assertion_msg(false, "TODO: CHECK OPEN NEXT CASE 2!");
|
||||
}
|
||||
} else {
|
||||
const auto pn_last = m_data.point_2(next, next_time);
|
||||
const auto dirn = Vector_2(pn_last, pn_curr);
|
||||
shifted_next = pn_curr - dirn / FT(10);
|
||||
if (m_debug) std::cout << "- including iedge, next" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- including iedge, next" << std::endl;
|
||||
}
|
||||
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- shifting prev: " << m_data.to_3d(pvertex.first, shifted_prev) << std::endl;
|
||||
std::cout << "- shifting next: " << m_data.to_3d(pvertex.first, shifted_next) << std::endl;
|
||||
}
|
||||
|
|
@ -2200,7 +2201,7 @@ private:
|
|||
}
|
||||
|
||||
CGAL_assertion(crossed_iedges.size() > 0);
|
||||
if (m_debug) {
|
||||
if (m_parameters.debug) {
|
||||
std::cout << "- crossed " << crossed_iedges.size() << " iedges: " << std::endl;
|
||||
for (const auto& crossed_iedge : crossed_iedges) {
|
||||
std::cout << m_data.str(crossed_iedge.first) << ": " <<
|
||||
|
|
@ -2218,27 +2219,27 @@ private:
|
|||
new_pvertices.clear();
|
||||
new_pvertices.resize(crossed_iedges.size(), m_data.null_pvertex());
|
||||
|
||||
if (m_debug) std::cout << "- open, 1 edge case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, 1 edge case" << std::endl;
|
||||
|
||||
Point_2 future_point;
|
||||
Vector_2 future_direction;
|
||||
bool is_parallel = false;
|
||||
if (KSR::distance(m_data.point_2(prev), m_data.point_2(next)) < KSR::point_tolerance<FT>()) {
|
||||
if (m_debug) std::cout << "- prev = next, equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev = next, equal points case" << std::endl;
|
||||
CGAL_assertion_msg(false,
|
||||
"TODO: OPEN, 1 EDGE CASE, FIX CASE WITH EQUAL PREV AND NEXT! SEE BACK CASE FOR REFERENCE!");
|
||||
} else {
|
||||
if (m_debug) std::cout << "- prev, next, not equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev, next, not equal points case" << std::endl;
|
||||
is_parallel = m_data.compute_future_point_and_direction(
|
||||
pvertex, ivertex, prev, next,
|
||||
crossed_iedges[0].first, future_point, future_direction);
|
||||
}
|
||||
|
||||
if (is_parallel) {
|
||||
if (m_debug) std::cout << "- parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- parallel case" << std::endl;
|
||||
CGAL_assertion_msg(!is_parallel, "TODO: OPEN, 1 EDGE CASE, ADD PARALLEL CASE!");
|
||||
} else {
|
||||
if (m_debug) std::cout << "- standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- standard case" << std::endl;
|
||||
}
|
||||
|
||||
const auto cropped1 = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
|
||||
|
|
@ -2262,7 +2263,7 @@ private:
|
|||
CGAL_assertion(future_direction != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_point);
|
||||
m_data.direction(cropped) = future_direction;
|
||||
if (m_debug) std::cout << "- cropped: " <<
|
||||
if (m_parameters.debug) std::cout << "- cropped: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
CGAL_assertion(m_data.is_correctly_oriented(
|
||||
cropped.first, future_direction, ivertex, crossed_iedges[0].first));
|
||||
|
|
@ -2284,14 +2285,14 @@ private:
|
|||
m_data.point_2(pvertex.first, m_data.target(crossed_iedges.front().first))) >= KSR::point_tolerance<FT>(),
|
||||
"TODO: OPEN, FRONT, HANDLE ZERO-LENGTH IEDGE!");
|
||||
|
||||
if (m_debug) std::cout << "- getting future point and direction, front" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- getting future point and direction, front" << std::endl;
|
||||
bool is_parallel = false;
|
||||
if (KSR::distance(m_data.point_2(prev), m_data.point_2(next)) < KSR::point_tolerance<FT>()) {
|
||||
if (m_debug) std::cout << "- prev = next, equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev = next, equal points case" << std::endl;
|
||||
CGAL_assertion_msg(false,
|
||||
"TODO: OPEN, FRONT, FIX CASE WITH EQUAL PREV AND NEXT! SEE BACK CASE FOR REFERENCE!");
|
||||
} else {
|
||||
if (m_debug) std::cout << "- prev, next, not equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev, next, not equal points case" << std::endl;
|
||||
is_parallel = m_data.compute_future_point_and_direction(
|
||||
pvertex, ivertex, prev, next,
|
||||
crossed_iedges.front().first, future_points.front(), future_directions.front());
|
||||
|
|
@ -2313,14 +2314,14 @@ private:
|
|||
m_data.point_2(pvertex.first, m_data.target(crossed_iedges.back().first))) >= KSR::point_tolerance<FT>(),
|
||||
"TODO: OPEN, BACK, HANDLE ZERO-LENGTH IEDGE!");
|
||||
|
||||
if (m_debug) std::cout << "- getting future point and direction, back" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- getting future point and direction, back" << std::endl;
|
||||
bool is_parallel = false;
|
||||
if (KSR::distance(m_data.point_2(prev), m_data.point_2(next)) < KSR::point_tolerance<FT>()) {
|
||||
if (m_debug) std::cout << "- prev = next, equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev = next, equal points case" << std::endl;
|
||||
CGAL_assertion_msg(false,
|
||||
"TODO: OPEN, BACK, FIX CASE WITH EQUAL PREV AND NEXT! SEE BACK CASE FOR REFERENCE!");
|
||||
} else {
|
||||
if (m_debug) std::cout << "- prev, next, not equal points case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- prev, next, not equal points case" << std::endl;
|
||||
is_parallel = m_data.compute_future_point_and_direction(
|
||||
pvertex, ivertex, prev, next,
|
||||
crossed_iedges.back().first, future_points.back(), future_directions.back());
|
||||
|
|
@ -2342,7 +2343,7 @@ private:
|
|||
{ // first crop
|
||||
PVertex cropped = m_data.null_pvertex();
|
||||
if (next_iedge == crossed_iedges.front().first) {
|
||||
if (m_debug) std::cout << "- open, next, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, next, parallel case" << std::endl;
|
||||
|
||||
// In case, we are parallel, we update the future point and direction.
|
||||
cropped = next;
|
||||
|
|
@ -2351,7 +2352,7 @@ private:
|
|||
0, ivertex, next, nnext, next_iedge, future_points.front(), future_directions.front());
|
||||
|
||||
} else {
|
||||
if (m_debug) std::cout << "- open, next, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, next, standard case" << std::endl;
|
||||
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
|
||||
}
|
||||
|
||||
|
|
@ -2368,7 +2369,7 @@ private:
|
|||
CGAL_assertion(future_directions.front() != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_points.front());
|
||||
m_data.direction(cropped) = future_directions.front();
|
||||
if (m_debug) std::cout << "- cropped 1: " <<
|
||||
if (m_parameters.debug) std::cout << "- cropped 1: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
CGAL_assertion(m_data.is_correctly_oriented(
|
||||
cropped.first, future_directions.front(), ivertex, crossed_iedges.front().first));
|
||||
|
|
@ -2377,7 +2378,7 @@ private:
|
|||
{ // second crop
|
||||
PVertex cropped = m_data.null_pvertex();
|
||||
if (prev_iedge == crossed_iedges.back().first) {
|
||||
if (m_debug) std::cout << "- open, prev, parallel case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, prev, parallel case" << std::endl;
|
||||
|
||||
// In case, we are parallel, we update the future point and direction.
|
||||
cropped = prev;
|
||||
|
|
@ -2386,7 +2387,7 @@ private:
|
|||
0, ivertex, prev, pprev, prev_iedge, future_points.back(), future_directions.back());
|
||||
|
||||
} else {
|
||||
if (m_debug) std::cout << "- open, prev, standard case" << std::endl;
|
||||
if (m_parameters.debug) std::cout << "- open, prev, standard case" << std::endl;
|
||||
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, prev.second));
|
||||
}
|
||||
|
||||
|
|
@ -2403,7 +2404,7 @@ private:
|
|||
CGAL_assertion(future_directions.back() != Vector_2());
|
||||
m_data.support_plane(cropped).set_point(cropped.second, future_points.back());
|
||||
m_data.direction(cropped) = future_directions.back();
|
||||
if (m_debug) std::cout << "- cropped 2: " <<
|
||||
if (m_parameters.debug) std::cout << "- cropped 2: " <<
|
||||
m_data.str(cropped) << ", " << m_data.point_3(cropped) << std::endl;
|
||||
CGAL_assertion(m_data.is_correctly_oriented(
|
||||
cropped.first, future_directions.back(), ivertex, crossed_iedges.back().first));
|
||||
|
|
|
|||
|
|
@ -29,6 +29,8 @@
|
|||
// Internal includes.
|
||||
#include <CGAL/KSR/utils.h>
|
||||
#include <CGAL/KSR/debug.h>
|
||||
#include <CGAL/KSR/parameters.h>
|
||||
|
||||
#include <CGAL/KSR_3/Data_structure.h>
|
||||
#include <CGAL/KSR_3/Reconstruction.h>
|
||||
#include <CGAL/KSR_3/Initializer.h>
|
||||
|
|
@ -61,11 +63,10 @@ private:
|
|||
using Polygon_mesh = CGAL::Surface_mesh<Point_3>;
|
||||
using Vertex_index = typename Polygon_mesh::Vertex_index;
|
||||
using Timer = CGAL::Real_timer;
|
||||
using Parameters = KSR::Parameters_3<FT>;
|
||||
|
||||
private:
|
||||
const bool m_verbose;
|
||||
const bool m_export;
|
||||
const bool m_debug;
|
||||
Parameters m_parameters;
|
||||
Data_structure m_data;
|
||||
std::size_t m_num_events;
|
||||
|
||||
|
|
@ -73,10 +74,8 @@ public:
|
|||
Kinetic_shape_reconstruction_3(
|
||||
const bool verbose = true,
|
||||
const bool debug = false) :
|
||||
m_verbose(verbose),
|
||||
m_export(false),
|
||||
m_debug(debug),
|
||||
m_data(m_debug),
|
||||
m_parameters(verbose, debug, false),
|
||||
m_data(m_parameters),
|
||||
m_num_events(0)
|
||||
{ }
|
||||
|
||||
|
|
@ -90,14 +89,16 @@ public:
|
|||
const NamedParameters& np) {
|
||||
|
||||
Timer timer;
|
||||
const unsigned int k = parameters::choose_parameter(
|
||||
m_parameters.k = parameters::choose_parameter(
|
||||
parameters::get_parameter(np, internal_np::k_intersections), 1);
|
||||
unsigned int n = parameters::choose_parameter(
|
||||
m_parameters.n = parameters::choose_parameter(
|
||||
parameters::get_parameter(np, internal_np::n_subdivisions), 0);
|
||||
FT enlarge_bbox_ratio = parameters::choose_parameter(
|
||||
m_parameters.enlarge_bbox_ratio = parameters::choose_parameter(
|
||||
parameters::get_parameter(np, internal_np::enlarge_bbox_ratio), FT(11) / FT(10));
|
||||
const bool reorient = parameters::choose_parameter(
|
||||
m_parameters.reorient = parameters::choose_parameter(
|
||||
parameters::get_parameter(np, internal_np::reorient), false);
|
||||
m_parameters.use_hybrid_mode = parameters::choose_parameter(
|
||||
parameters::get_parameter(np, internal_np::use_hybrid_mode), false);
|
||||
|
||||
std::cout.precision(20);
|
||||
if (input_range.size() == 0) {
|
||||
|
|
@ -106,34 +107,34 @@ public:
|
|||
return false;
|
||||
}
|
||||
|
||||
if (n != 0) {
|
||||
if (m_parameters.n != 0) {
|
||||
CGAL_assertion_msg(false, "TODO: IMPLEMENT KINETIC SUBDIVISION!");
|
||||
if (n > 3) {
|
||||
CGAL_warning_msg(n <= 3,
|
||||
if (m_parameters.n > 3) {
|
||||
CGAL_warning_msg(m_parameters.n <= 3,
|
||||
"WARNING: DOES IT MAKE SENSE TO HAVE MORE THAN 64 INPUT BLOCKS? SETTING N TO 3!");
|
||||
n = 3;
|
||||
m_parameters.n = 3;
|
||||
}
|
||||
}
|
||||
|
||||
if (enlarge_bbox_ratio < FT(1)) {
|
||||
CGAL_warning_msg(enlarge_bbox_ratio >= FT(1),
|
||||
if (m_parameters.enlarge_bbox_ratio < FT(1)) {
|
||||
CGAL_warning_msg(m_parameters.enlarge_bbox_ratio >= FT(1),
|
||||
"WARNING: YOU SET ENLARGE_BBOX_RATIO < 1.0! THE VALID RANGE IS [1.0, +INF). SETTING TO 1.0!");
|
||||
enlarge_bbox_ratio = FT(1);
|
||||
m_parameters.enlarge_bbox_ratio = FT(1);
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
const unsigned int num_blocks = std::pow(n + 1, 3);
|
||||
const std::string is_reorient = (reorient ? "true" : "false");
|
||||
if (m_parameters.verbose) {
|
||||
const unsigned int num_blocks = std::pow(m_parameters.n + 1, 3);
|
||||
const std::string is_reorient = (m_parameters.reorient ? "true" : "false");
|
||||
|
||||
std::cout << std::endl << "--- PARTITION OPTIONS: " << std::endl;
|
||||
std::cout << "* number of intersections k: " << k << std::endl;
|
||||
std::cout << "* number of subdivisions per bbox side: " << n << std::endl;
|
||||
std::cout << "* number of subdivision blocks: " << num_blocks << std::endl;
|
||||
std::cout << "* enlarge bbox ratio: " << enlarge_bbox_ratio << std::endl;
|
||||
std::cout << "* reorient: " << is_reorient << std::endl;
|
||||
std::cout << "* number of intersections k: " << m_parameters.k << std::endl;
|
||||
std::cout << "* number of subdivisions per bbox side: " << m_parameters.n << std::endl;
|
||||
std::cout << "* number of subdivision blocks: " << num_blocks << std::endl;
|
||||
std::cout << "* enlarge bbox ratio: " << m_parameters.enlarge_bbox_ratio << std::endl;
|
||||
std::cout << "* reorient: " << is_reorient << std::endl;
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << std::endl << "--- INITIALIZING PARTITION:" << std::endl;
|
||||
}
|
||||
|
||||
|
|
@ -141,13 +142,12 @@ public:
|
|||
timer.reset();
|
||||
timer.start();
|
||||
m_data.clear();
|
||||
Initializer initializer(m_verbose, m_export, m_debug, m_data);
|
||||
const FT time_step = static_cast<FT>(initializer.initialize(
|
||||
input_range, polygon_map, k, CGAL::to_double(enlarge_bbox_ratio), reorient));
|
||||
Initializer initializer(m_data, m_parameters);
|
||||
const FT time_step = static_cast<FT>(initializer.initialize(input_range, polygon_map));
|
||||
timer.stop();
|
||||
const double time_to_initialize = timer.time();
|
||||
|
||||
// if (m_verbose) {
|
||||
// if (m_parameters.verbose) {
|
||||
// std::cout << std::endl << "* initialization (sec.): " << time_to_initialize << std::endl;
|
||||
// std::cout << "INITIALIZATION SUCCESS!" << std::endl << std::endl;
|
||||
// }
|
||||
|
|
@ -158,13 +158,13 @@ public:
|
|||
// std::cout << m_data.support_plane(i).plane() << std::endl;
|
||||
// }
|
||||
|
||||
if (k == 0) { // for k = 0, we skip propagation
|
||||
CGAL_warning_msg(k > 0,
|
||||
if (m_parameters.k == 0) { // for k = 0, we skip propagation
|
||||
CGAL_warning_msg(m_parameters.k > 0,
|
||||
"WARNING: YOU SET K TO 0! THAT MEANS NO PROPAGATION! THE VALID VALUES ARE {1,2,...}. INTERSECT AND RETURN!");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << std::endl << "--- RUNNING THE QUEUE:" << std::endl;
|
||||
std::cout << "* propagation started" << std::endl;
|
||||
}
|
||||
|
|
@ -173,54 +173,54 @@ public:
|
|||
timer.reset();
|
||||
timer.start();
|
||||
std::size_t num_queue_calls = 0;
|
||||
Propagation propagation(m_verbose, m_export, m_debug, m_data);
|
||||
Propagation propagation(m_data, m_parameters);
|
||||
std::tie(num_queue_calls, m_num_events) = propagation.propagate(time_step);
|
||||
timer.stop();
|
||||
const double time_to_propagate = timer.time();
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* propagation finished" << std::endl;
|
||||
std::cout << "* number of queue calls: " << num_queue_calls << std::endl;
|
||||
std::cout << "* number of events handled: " << m_num_events << std::endl;
|
||||
}
|
||||
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << std::endl << "--- FINALIZING PARTITION:" << std::endl;
|
||||
}
|
||||
|
||||
// Finalization.
|
||||
timer.reset();
|
||||
timer.start();
|
||||
if (m_debug) dump(m_data, "jiter-final-a-result");
|
||||
if (m_parameters.debug) dump(m_data, "jiter-final-a-result");
|
||||
|
||||
Finalizer finalizer(m_verbose, m_export, m_debug, m_data);
|
||||
Finalizer finalizer(m_data, m_parameters);
|
||||
finalizer.clean();
|
||||
|
||||
if (m_verbose) std::cout << "* checking final mesh integrity ...";
|
||||
if (m_parameters.verbose) std::cout << "* checking final mesh integrity ...";
|
||||
CGAL_assertion(m_data.check_integrity(true, true, true));
|
||||
if (m_verbose) std::cout << " done" << std::endl;
|
||||
if (m_parameters.verbose) std::cout << " done" << std::endl;
|
||||
|
||||
if (m_debug) dump(m_data, "jiter-final-b-result");
|
||||
if (m_parameters.debug) dump(m_data, "jiter-final-b-result");
|
||||
// std::cout << std::endl << "CLEANING SUCCESS!" << std::endl << std::endl;
|
||||
// exit(EXIT_SUCCESS);
|
||||
|
||||
if (m_verbose) std::cout << "* getting volumes ..." << std::endl;
|
||||
if (m_parameters.verbose) std::cout << "* getting volumes ..." << std::endl;
|
||||
finalizer.create_polyhedra();
|
||||
timer.stop();
|
||||
const double time_to_finalize = timer.time();
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* found all together " << m_data.number_of_volumes(-1) << " volumes" << std::endl;
|
||||
}
|
||||
// std::cout << std::endl << "CREATING VOLUMES SUCCESS!" << std::endl << std::endl;
|
||||
// exit(EXIT_SUCCESS);
|
||||
|
||||
// Timing.
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << std::endl << "--- TIMING (sec.):" << std::endl;
|
||||
}
|
||||
const double total_time =
|
||||
time_to_initialize + time_to_propagate + time_to_finalize;
|
||||
if (m_verbose) {
|
||||
if (m_parameters.verbose) {
|
||||
std::cout << "* initialization: " << time_to_initialize << std::endl;
|
||||
std::cout << "* propagation: " << time_to_propagate << std::endl;
|
||||
std::cout << "* finalization: " << time_to_finalize << std::endl;
|
||||
|
|
@ -246,7 +246,7 @@ public:
|
|||
InputRange, PointMap, VectorMap, SemanticMap, Kernel>;
|
||||
|
||||
Reconstruction reconstruction(
|
||||
input_range, point_map, normal_map, semantic_map, m_data, m_verbose, m_debug);
|
||||
input_range, point_map, normal_map, semantic_map, m_data, m_parameters.verbose, m_parameters.debug);
|
||||
bool success = reconstruction.detect_planar_shapes(np);
|
||||
if (!success) {
|
||||
CGAL_assertion_msg(false, "ERROR: RECONSTRUCTION, DETECTING PLANAR SHAPES FAILED!");
|
||||
|
|
|
|||
Loading…
Reference in New Issue