songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

more refined output

This commit is contained in:
Dmitry Anisimov 2021-06-23 17:30:24 +02:00
parent 80611bfb81
commit cb689a8d16
5 changed files with 110 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Kinetic_shape_reconstruction/examples/Kinetic_shape_reconstruction/kinetic_precomputed_shapes_example.cpp
View File

@ -165,8 +165,8 @@ int main(const int argc, const char** argv) {
std::cout << "* number of events: " << num_events << std::endl;
// Export.
std::cout << std::endl;
std::cout << "--- EXPORT: " << std::endl;
// std::cout << std::endl;
// std::cout << "--- EXPORT: " << std::endl;
// Vertices.
// std::string output_filename = "partition-vertices.xyz";

2
Kinetic_shape_reconstruction/include/CGAL/KSR/debug.h
View File

@ -312,7 +312,7 @@ public:
using Random = CGAL::Random;
Saver() :
m_path_prefix("/Users/monet/Documents/fork/pull-requests/kinetic/logs/"),
m_path_prefix(""),
grey(Color(125, 125, 125)),
red(Color(125, 0, 0))
{ }

16
Kinetic_shape_reconstruction/include/CGAL/KSR_3/Finalizer.h
View File

@ -962,14 +962,16 @@ private:
if (m_verbose) {
std::cout << "* created volumes: " << volumes.size() << std::endl;
if (m_export) dump_volumes(m_data, "volumes/final");
if (m_export) 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);
std::cout <<
" VOLUME " << std::to_string(i) << ": "
" pvertices: " << volume.pvertices.size() <<
" pfaces: " << volume.pfaces.size() << std::endl;
if (m_debug) {
std::cout <<
" VOLUME " << std::to_string(i) << ": "
" pvertices: " << volume.pvertices.size() <<
" pfaces: " << volume.pfaces.size() << std::endl;
}
}
}
@ -1012,7 +1014,7 @@ private:
volume_size, volume_centroid, map_volumes, queue);
}
if (m_verbose) {
if (m_debug) {
std::cout << "- FOUND VOLUME " << volume_index << ", (SIZE/BARYCENTER): "
<< volume_size << " / " << volume_centroid << std::endl;
}
@ -1060,7 +1062,7 @@ private:
false, query, volume_index, num_volumes, centroids,
volume_size, volume_centroid, map_volumes, queue);
}
if (m_verbose) {
if (m_debug) {
std::cout << "- FOUND VOLUME " << volume_index << ", (SIZE/BARYCENTER): "
<< volume_size << " / " << volume_centroid << std::endl;
}

190
Kinetic_shape_reconstruction/include/CGAL/KSR_3/Propagation.h
View File

@ -984,7 +984,7 @@ private:
PVertex crop_pvertex_along_iedge(
const PVertex& pvertex, const IEdge& iedge) {
if (m_verbose) {
if (m_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;
@ -1010,7 +1010,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_verbose) std::cout << "- pvertex to iedge, parallel case" << std::endl;
if (m_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!");
}
@ -1018,7 +1018,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_verbose) {
if (m_debug) {
std::cout << "- new pedge: " << m_data.str(pedge) << " between "
<< m_data.str(pvertex) << " and " << m_data.str(pother) << std::endl;
}
@ -1032,7 +1032,7 @@ private:
m_data.direction(pvertex) = future_direction_a;
m_data.direction(pother) = future_direction_b;
if (m_verbose) std::cout << "- new pvertices: " <<
if (m_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!");
@ -1042,7 +1042,7 @@ private:
std::array<PVertex, 3> propagate_pvertex_beyond_iedge(
const PVertex& pvertex, const IEdge& iedge) {
if (m_verbose) {
if (m_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;
@ -1056,7 +1056,7 @@ private:
const PVertex propagated = m_data.add_pvertex(pvertex.first, original_point);
m_data.direction(propagated) = original_direction;
if (m_verbose) {
if (m_debug) {
std::cout << "- propagated: " << m_data.str(propagated) << ": " << m_data.point_3(propagated) << std::endl;
}
@ -1068,7 +1068,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_verbose) {
if (m_debug) {
std::cout << "- new pface " << m_data.str(new_pface) << ": " <<
m_data.centroid_of_pface(new_pface) << std::endl;
}
@ -1080,7 +1080,7 @@ private:
void crop_pedge_along_iedge(
const PVertex& pvertex, const PVertex& pother, const IEdge& iedge) {
if (m_verbose) {
if (m_debug) {
std::cout.precision(20);
std::cout << "** cropping pedge [" << m_data.str(pvertex) << "-" << m_data.str(pother)
<< "] along " << m_data.str(iedge) << std::endl;
@ -1100,7 +1100,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_verbose) {
if (m_debug) {
std::cout << "- prev pv: " << m_data.point_3(prev) << std::endl;
std::cout << "- next pv: " << m_data.point_3(next) << std::endl;
}
@ -1114,7 +1114,7 @@ private:
}
CGAL_assertion(pthird != m_data.null_pvertex());
if (m_verbose) {
if (m_debug) {
std::cout << "- pthird pv: " << m_data.point_3(pthird) << std::endl;
}
@ -1122,7 +1122,7 @@ private:
0, IVertex(), pvertex, pthird, iedge, future_point, future_direction);
CGAL_assertion(future_direction != Vector_2());
if (is_parallel) {
if (m_verbose) std::cout << "- pedge to iedge 1, parallel case" << std::endl;
if (m_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!");
}
@ -1136,7 +1136,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_verbose) {
if (m_debug) {
std::cout << "- prev po: " << m_data.point_3(prev) << std::endl;
std::cout << "- next po: " << m_data.point_3(next) << std::endl;
}
@ -1150,7 +1150,7 @@ private:
}
CGAL_assertion(pthird != m_data.null_pvertex());
if (m_verbose) {
if (m_debug) {
std::cout << "- pthird po: " << m_data.point_3(pthird) << std::endl;
}
@ -1158,7 +1158,7 @@ private:
0, IVertex(), pother, pthird, iedge, future_point, future_direction);
CGAL_assertion(future_direction != Vector_2());
if (is_parallel) {
if (m_verbose) std::cout << "- pedge to iedge 2, parallel case" << std::endl;
if (m_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!");
}
@ -1177,7 +1177,7 @@ private:
std::pair<PVertex, PVertex> propagate_pedge_beyond_iedge(
const PVertex& pvertex, const PVertex& pother, const IEdge& iedge) {
if (m_verbose) {
if (m_debug) {
std::cout.precision(20);
std::cout << "** propagating pedge [" << m_data.str(pvertex) << "-" << m_data.str(pother)
<< "] beyond " << m_data.str(iedge) << std::endl;
@ -1200,7 +1200,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_verbose) {
if (m_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) << ": " <<
@ -1216,7 +1216,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_verbose) {
if (m_debug) {
std::cout << "- new pface " << m_data.str(new_pface) << ": " << m_data.centroid_of_pface(new_pface) << std::endl;
}
@ -1227,7 +1227,7 @@ private:
bool transfer_pvertex_via_iedge(
const PVertex& pvertex, const PVertex& pother) {
if (m_verbose) {
if (m_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 "
@ -1242,12 +1242,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_verbose) std::cout << "- swap pfaces" << std::endl;
if (m_debug) std::cout << "- swap pfaces" << std::endl;
std::swap(source_pface, target_pface);
}
CGAL_assertion(common_pface == source_pface);
if (m_verbose) {
if (m_debug) {
std::cout << "- initial pfaces: " << std::endl;
if (source_pface != m_data.null_pface()) {
std::cout << "source " << m_data.str(source_pface) << ": " <<
@ -1262,7 +1262,7 @@ private:
// Get pthird.
PVertex pthird = m_data.next(pother);
if (pthird == pvertex) pthird = m_data.prev(pother);
if (m_verbose) std::cout << "- pthird: " << m_data.point_3(pthird) << std::endl;
if (m_debug) std::cout << "- pthird: " << m_data.point_3(pthird) << std::endl;
// Get future point and direction.
CGAL_assertion(m_data.has_iedge(pvertex));
@ -1280,7 +1280,7 @@ private:
0, IVertex(), pother, pthird, iedge, future_point, future_direction);
CGAL_assertion(future_direction != Vector_2());
if (is_parallel) {
if (m_verbose) std::cout << "- transfer pvertex, parallel case" << std::endl;
if (m_debug) std::cout << "- transfer pvertex, parallel case" << std::endl;
// CGAL_assertion_msg(!is_parallel,
// "TODO: TRANSFER PVERTEX, HANDLE CASE WITH PARALLEL LINES!");
}
@ -1313,11 +1313,11 @@ private:
CGAL_assertion(m_data.mesh(pedge).face(he) == common_pface.second);
if (m_data.mesh(pedge).target(he) == pvertex.second) {
// if (m_verbose) std::cout << "- shifting target" << std::endl;
// if (m_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_verbose) std::cout << "- shifting source" << std::endl;
// if (m_debug) std::cout << "- shifting source" << std::endl;
CGAL::Euler::shift_source(he, m_data.mesh(pedge));
}
@ -1335,7 +1335,7 @@ private:
// "TODO: TRANSFER PVERTEX 2, ADD NEW FUTURE POINTS AND DIRECTIONS!");
}
if (m_verbose) {
if (m_debug) {
std::cout << "- new pfaces: " << std::endl;
if (source_pface != m_data.null_pface()) {
std::cout << "source " << m_data.str(source_pface) << ": " <<
@ -1356,7 +1356,7 @@ private:
const PVertex& event_pvertex, const std::vector<PVertex>& pvertices,
std::vector< std::pair<IEdge, bool> >& crossed_iedges) {
if (m_verbose) {
if (m_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;
@ -1369,7 +1369,7 @@ private:
const PVertex next = pvertices.back();
const PVertex pvertex = pvertices[1];
if (m_verbose) {
if (m_debug) {
const auto iedge = m_data.iedge(pvertex);
if (iedge != m_data.null_iedge()) {
std::cout << "- start from: " << m_data.str(iedge) << " " <<
@ -1392,7 +1392,7 @@ private:
CGAL_assertion_msg(false, "ERROR: INVALID CONNECTIVITY CASE!");
}
if (m_verbose) {
if (m_debug) {
std::cout << "- found neighbors: " << std::endl <<
"prev = " << m_data.point_3(prev) << std::endl <<
"fron = " << m_data.point_3(front) << std::endl <<
@ -1415,7 +1415,7 @@ private:
m_data.support_plane(curr).set_point(curr.second, ipoint);
}
m_data.connect(pvertex, ivertex);
if (m_verbose) {
if (m_debug) {
std::cout << "- frozen pvertex: " << m_data.str(pvertex) << " : " << m_data.point_3(pvertex) << std::endl;
}
@ -1449,11 +1449,11 @@ private:
}
if (back_constrained && !front_constrained) {
if (m_verbose) std::cout << "- reverse iedges" << std::endl;
if (m_debug) std::cout << "- reverse iedges" << std::endl;
std::reverse(iedges.begin(), iedges.end());
}
if (m_verbose) {
if (m_debug) {
std::cout << "- initial iedges: " << iedges.size() << std::endl;
for (const auto& iedge : iedges) {
std::cout << m_data.str(iedge.first) << ": " <<
@ -1493,7 +1493,7 @@ private:
crossed_iedges.push_back(std::make_pair(m_data.iedge(pvertex), true));
}
if (m_verbose) {
if (m_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;
@ -1508,7 +1508,7 @@ private:
void apply_closing_case(const PVertex& pvertex) const {
if (m_verbose) {
if (m_debug) {
std::cout.precision(20);
std::cout << "*** CLOSING CASE" << std::endl;
}
@ -1527,7 +1527,7 @@ private:
std::vector< std::pair<IEdge, bool> >& crossed_iedges,
std::vector<PVertex>& new_pvertices) {
if (m_verbose) {
if (m_debug) {
std::cout.precision(20);
std::cout << "*** BACK BORDER CASE" << std::endl;
}
@ -1562,7 +1562,7 @@ private:
Point_2 shifted_prev;
const auto pp_curr = m_data.point_2(prev, curr_time);
if (prev_diff < tol) {
if (m_verbose) std::cout << "- back, same time events, prev" << std::endl;
if (m_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);
@ -1579,28 +1579,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_verbose) std::cout << "- found same time iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- excluding iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, prev" << std::endl;
if (m_debug) std::cout << "- including iedge, prev" << std::endl;
}
if (m_verbose) {
if (m_debug) {
std::cout << "- shifting prev: " << m_data.to_3d(pvertex.first, shifted_prev) << std::endl;
}
@ -1634,7 +1634,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_verbose) {
if (m_debug) {
std::cout << "- bbox: " << is_bbox_reached << "; limit: " << is_limit_reached << std::endl;
}
@ -1650,7 +1650,7 @@ private:
}
CGAL_assertion(crossed_iedges.size() > 0);
if (m_verbose) {
if (m_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) << ": " <<
@ -1672,12 +1672,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!
std::cout << "- back = prev, equal points case" << std::endl;
if (m_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 {
std::cout << "- back, prev, not equal points case" << std::endl;
if (m_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);
}
@ -1695,7 +1695,7 @@ private:
{ // crop
PVertex cropped = m_data.null_pvertex();
if (prev_iedge == iedge_0) {
if (m_verbose) std::cout << "- back, prev, parallel case" << std::endl;
if (m_debug) std::cout << "- back, prev, parallel case" << std::endl;
// In case, we are parallel, we update the future point and direction.
cropped = prev;
@ -1704,7 +1704,7 @@ private:
0, ivertex, prev, pprev, prev_iedge, future_point, future_direction);
} else {
if (m_verbose) std::cout << "- back, prev, standard case" << std::endl;
if (m_debug) std::cout << "- back, prev, standard case" << std::endl;
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, prev.second));
}
@ -1721,7 +1721,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_verbose) std::cout << "- cropped: " <<
if (m_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));
@ -1744,7 +1744,7 @@ private:
std::vector< std::pair<IEdge, bool> >& crossed_iedges,
std::vector<PVertex>& new_pvertices) {
if (m_verbose) {
if (m_debug) {
std::cout.precision(20);
std::cout << "*** FRONT BORDER CASE" << std::endl;
}
@ -1779,7 +1779,7 @@ private:
Point_2 shifted_next;
const auto pn_curr = m_data.point_2(next, curr_time);
if (next_diff < tol) {
if (m_verbose) std::cout << "- front, same time events, next" << std::endl;
if (m_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);
@ -1795,28 +1795,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_verbose) std::cout << "- found same time iedge, next" << std::endl;
if (m_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_verbose) std::cout << "- excluding iedge, next" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, next" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, next" << std::endl;
if (m_debug) std::cout << "- including iedge, next" << std::endl;
}
if (m_verbose) {
if (m_debug) {
std::cout << "- shifting next: " << m_data.to_3d(pvertex.first, shifted_next) << std::endl;
}
@ -1850,7 +1850,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_verbose) {
if (m_debug) {
std::cout << "- bbox: " << is_bbox_reached << "; limit: " << is_limit_reached << std::endl;
}
@ -1866,7 +1866,7 @@ private:
}
CGAL_assertion(crossed_iedges.size() > 0);
if (m_verbose) {
if (m_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) << ": " <<
@ -1886,11 +1886,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>()) {
std::cout << "- front = next, equal points case" << std::endl;
if (m_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 {
std::cout << "- front, next, not equal points case" << std::endl;
if (m_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);
}
@ -1908,7 +1908,7 @@ private:
{ // crop
PVertex cropped = m_data.null_pvertex();
if (next_iedge == iedge_0) {
if (m_verbose) std::cout << "- front, next, parallel case" << std::endl;
if (m_debug) std::cout << "- front, next, parallel case" << std::endl;
// In case, we are parallel, we update the future point and direction.
cropped = next;
@ -1917,7 +1917,7 @@ private:
0, ivertex, next, nnext, next_iedge, future_point, future_direction);
} else {
if (m_verbose) std::cout << "- front, next, standard case" << std::endl;
if (m_debug) std::cout << "- front, next, standard case" << std::endl;
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
}
@ -1934,7 +1934,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_verbose) std::cout << "- cropped: " <<
if (m_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));
@ -1959,7 +1959,7 @@ private:
std::vector< std::pair<IEdge, bool> >& crossed_iedges,
std::vector<PVertex>& new_pvertices) {
if (m_verbose) {
if (m_debug) {
std::cout.precision(20);
std::cout << "*** OPEN CASE" << std::endl;
}
@ -1999,7 +1999,7 @@ private:
Point_2 shifted_prev;
const auto pp_curr = m_data.point_2(prev, curr_time);
if (prev_diff < tol) {
if (m_verbose) std::cout << "- open, same time events, prev" << std::endl;
if (m_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);
@ -2015,31 +2015,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_verbose) std::cout << "- found same time iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- excluding iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, prev" << std::endl;
if (m_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_verbose) std::cout << "- open, same time events, next" << std::endl;
if (m_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);
@ -2055,28 +2055,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_verbose) std::cout << "- found same time iedge, next" << std::endl;
if (m_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_verbose) std::cout << "- excluding iedge, next" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, next" << std::endl;
if (m_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_verbose) std::cout << "- including iedge, next" << std::endl;
if (m_debug) std::cout << "- including iedge, next" << std::endl;
}
if (m_verbose) {
if (m_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;
}
@ -2130,7 +2130,7 @@ private:
}
CGAL_assertion(crossed_iedges.size() > 0);
if (m_verbose) {
if (m_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) << ": " <<
@ -2148,23 +2148,27 @@ private:
new_pvertices.clear();
new_pvertices.resize(crossed_iedges.size(), m_data.null_pvertex());
if (m_verbose) std::cout << "- open, 1 edge case" << std::endl;
if (m_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;
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;
is_parallel = m_data.compute_future_point_and_direction(
pvertex, ivertex, prev, next,
crossed_iedges[0].first, future_point, future_direction);
}
const bool 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_verbose) std::cout << "- parallel case" << std::endl;
if (m_debug) std::cout << "- parallel case" << std::endl;
CGAL_assertion_msg(!is_parallel, "TODO: OPEN, 1 EDGE CASE, ADD PARALLEL CASE!");
} else {
if (m_verbose) std::cout << "- standard case" << std::endl;
if (m_debug) std::cout << "- standard case" << std::endl;
}
const auto cropped1 = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
@ -2188,7 +2192,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_verbose) std::cout << "- cropped: " <<
if (m_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));
@ -2210,14 +2214,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_verbose) std::cout << "- getting future point and direction, front" << std::endl;
if (m_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>()) {
std::cout << "- prev = next, equal points case" << std::endl;
if (m_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 {
std::cout << "- prev, next, not equal points case" << std::endl;
if (m_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());
@ -2239,14 +2243,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_verbose) std::cout << "- getting future point and direction, back" << std::endl;
if (m_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>()) {
std::cout << "- prev = next, equal points case" << std::endl;
if (m_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 {
std::cout << "- prev, next, not equal points case" << std::endl;
if (m_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());
@ -2268,7 +2272,7 @@ private:
{ // first crop
PVertex cropped = m_data.null_pvertex();
if (next_iedge == crossed_iedges.front().first) {
if (m_verbose) std::cout << "- open, next, parallel case" << std::endl;
if (m_debug) std::cout << "- open, next, parallel case" << std::endl;
// In case, we are parallel, we update the future point and direction.
cropped = next;
@ -2277,7 +2281,7 @@ private:
0, ivertex, next, nnext, next_iedge, future_points.front(), future_directions.front());
} else {
if (m_verbose) std::cout << "- open, next, standard case" << std::endl;
if (m_debug) std::cout << "- open, next, standard case" << std::endl;
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, next.second));
}
@ -2294,7 +2298,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_verbose) std::cout << "- cropped 1: " <<
if (m_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));
@ -2303,7 +2307,7 @@ private:
{ // second crop
PVertex cropped = m_data.null_pvertex();
if (prev_iedge == crossed_iedges.back().first) {
if (m_verbose) std::cout << "- open, prev, parallel case" << std::endl;
if (m_debug) std::cout << "- open, prev, parallel case" << std::endl;
// In case, we are parallel, we update the future point and direction.
cropped = prev;
@ -2312,7 +2316,7 @@ private:
0, ivertex, prev, pprev, prev_iedge, future_points.back(), future_directions.back());
} else {
if (m_verbose) std::cout << "- open, prev, standard case" << std::endl;
if (m_debug) std::cout << "- open, prev, standard case" << std::endl;
cropped = PVertex(pvertex.first, m_data.support_plane(pvertex).split_edge(pvertex.second, prev.second));
}
@ -2329,7 +2333,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_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));

2
Kinetic_shape_reconstruction/include/CGAL/Kinetic_shape_reconstruction_3.h
View File

@ -209,7 +209,7 @@ public:
timer.stop();
const double time_to_finalize = timer.time();
if (m_verbose) {
std::cout << "* found " << m_data.number_of_volumes(-1) << " volumes" << std::endl;
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);