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

added missing ref + better syntaxis

This commit is contained in:
Dmitry Anisimov 2021-05-31 18:06:02 +02:00
parent 0c5d8ed8ed
commit 61499c6fff
23 changed files with 238 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Documentation/doc/biblio/cgal_manual.bib
View File

@ -264,6 +264,16 @@ Boissonnat}
update = "09.12 penarand"
}
@inproceedings{cgal:bl-kippi-18,
author = {Bauchet, Jean-Philippe and Lafarge, Florent},
title = {{KIPPI: KInetic Polygonal Partitioning of Images}},
booktitle = {{IEEE Conference on Computer Vision and Pattern Recognition (CVPR)}},
address = {Salt Lake City, United States},
year = {2018},
month = {Jun},
pages = {3146--3154}
}
@book{ cgal:bn-sec++-94
,author = "J. J. Barton and L. R. Nackman"
,title = "Scientific and Engineering {C{\tt ++}}"

8
Shape_regularization/benchmark/Shape_regularization/benchmark_contours.cpp
View File

@ -161,11 +161,12 @@ void benchmark_contours(
open_time /= static_cast<double>(num_iters);
std::cout.precision(10);
if (simple_output)
if (simple_output) {
std::cout << contour.size() << " " << closed_time << " " << open_time << std::endl;
else
} else {
std::cout << "benchmark_contours " << contour.size() << " (CPU time " <<
"closed/open): " << closed_time << "/" << open_time << " seconds" << std::endl;
}
}
int main() {
@ -174,8 +175,9 @@ int main() {
const std::vector<std::size_t> ns = {
10, 100, 1000, 10000, 100000, 1000000, 10000000
};
for (const std::size_t n : ns)
for (const std::size_t n : ns) {
benchmark_contours(n, false, num_iters);
}
// Dense results for plotting.
// std::vector<std::size_t> ns;

18
Shape_regularization/benchmark/Shape_regularization/benchmark_qp_segments.cpp
View File

@ -138,8 +138,9 @@ void benchmark_qp_segments(
group.reserve(m);
for (std::size_t i = 0; i < n;) {
group.clear();
for (std::size_t j = 0; j < m; ++j)
for (std::size_t j = 0; j < m; ++j) {
group.push_back(i + j);
}
neighbor_query.add_group(group);
i += m;
}
@ -157,8 +158,9 @@ void benchmark_qp_segments(
group.reserve(m);
for (std::size_t i = 0; i < n;) {
group.clear();
for (std::size_t j = 0; j < m; ++j)
for (std::size_t j = 0; j < m; ++j) {
group.push_back(i + j);
}
angle_regularization.add_group(group);
i += m;
}
@ -218,8 +220,9 @@ void benchmark_qp_segments(
offset_time /= static_cast<double>(num_iters);
std::cout.precision(10);
if (regroup && !simple_output)
if (regroup && !simple_output) {
std::cout << "grouped: " ;
}
// std::cout << "benchmark_qp_segments " << segments.size() << " (CPU time " <<
// "delaunay/setup_angles/angles/setup_offsets/offsets): " <<
@ -228,15 +231,16 @@ void benchmark_qp_segments(
// setup_offset_time << "/" << offset_time <<
// " seconds" << std::endl;
if (!simple_output)
if (!simple_output) {
std::cout << "benchmark_qp_segments " << segments.size() << " (CPU time " <<
"angles/offsets): " << angle_time << "/" << offset_time << " seconds" << std::endl;
else {
if (!regroup)
} else {
if (!regroup) {
std::cout << segments.size() << " " << angle_time << " " << offset_time << " ";
else
} else {
std::cout << angle_time << " " << offset_time << std::endl;
}
}
}
int main() {

24
Shape_regularization/examples/Shape_regularization/include/Saver.h
View File

@ -55,8 +55,9 @@ public:
const FT stub = FT(0);
std::vector<Segment_2> edges;
for (const std::size_t seg_index : group)
for (const std::size_t seg_index : group) {
edges.push_back(segments[seg_index]);
}
export_segments(edges, path, stub);
}
@ -65,8 +66,9 @@ public:
const std::string path,
const FT) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
const FT stub = FT(0);
std::vector<Segment_2> segments;
@ -88,8 +90,9 @@ public:
const std::string path,
const FT) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
const FT stub = FT(0);
std::vector<Segment_2> segments;
@ -111,8 +114,7 @@ public:
const std::string path,
FT scale) {
if (input.size() == 0)
return;
if (input.size() == 0) return;
clear();
// Compute barycenter.
@ -165,8 +167,9 @@ public:
const FT stub = FT(0);
std::vector<Segment_2> edges;
for (const std::size_t seg_index : group)
for (const std::size_t seg_index : group) {
edges.push_back(segments[seg_index]);
}
export_eps_segments(edges, path, stub);
}
@ -175,8 +178,9 @@ public:
const std::string path,
FT scale) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
std::vector<Segment_2> segments;
const std::size_t n = contour.size();
@ -197,8 +201,9 @@ public:
const std::string path,
FT scale) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
std::vector<Segment_2> segments;
const std::size_t n = contour.size();
@ -240,8 +245,9 @@ private:
const std::vector<Polyline>& polylines,
const std::string path) {
if (polylines.size() == 0)
if (polylines.size() == 0) {
return;
}
clear();
for (std::size_t i = 0; i < polylines.size(); ++i) {

3
Shape_regularization/examples/Shape_regularization/include/utils.h
View File

@ -81,8 +81,9 @@ double get_coefficient_value(
(theta > 3.0 * CGAL_PI / 2.0 && theta < 7.0 * CGAL_PI / 4.0)) {
iterator += 0.02;
} else
} else {
iterator -= 0.02;
}
if (theta < CGAL_PI) return -1.0 * iterator;
return iterator;

3
Shape_regularization/examples/Shape_regularization/regularize_framework.cpp
View File

@ -52,8 +52,9 @@ public:
bool solve(OutputIterator solution) {
// 3 = 2 objects + 1 edge between them
for (std::size_t i = 0; i < 3; ++i)
for (std::size_t i = 0; i < 3; ++i) {
*(++solution) = NT(0);
}
return true;
}
};

8
Shape_regularization/include/CGAL/Shape_regularization/Contours/Longest_direction_2.h
View File

@ -92,15 +92,17 @@ namespace Contours {
CGAL_precondition(m_input_range.size() >= 2);
if (is_closed)
if (is_closed) {
estimate_closed(m_bounds, m_directions, m_assigned);
else
} else {
estimate_open(m_bounds, m_directions, m_assigned);
}
if (verbose()) {
std::cout << "* assigned directions: ";
for (std::size_t direction_index : m_assigned)
for (std::size_t direction_index : m_assigned) {
std::cout << direction_index << " ";
}
std::cout << std::endl;
}
}

23
Shape_regularization/include/CGAL/Shape_regularization/Contours/Multiple_directions_2.h
View File

@ -143,15 +143,17 @@ namespace Contours {
CGAL_precondition(
m_min_length_2 >= FT(0));
if (is_closed)
if (is_closed) {
estimate_closed(m_bounds, m_directions, m_assigned);
else
} else {
estimate_open(m_bounds, m_directions, m_assigned);
}
if (verbose()) {
std::cout << "* assigned directions: ";
for (std::size_t direction_index : m_assigned)
for (std::size_t direction_index : m_assigned) {
std::cout << direction_index << " ";
}
std::cout << std::endl;
}
}
@ -257,10 +259,11 @@ namespace Contours {
} else {
m_base.unify_along_contours_closed(wraps, assigned);
m_base.correct_directions_closed(wraps, assigned);
if (m_adjust_directions)
if (m_adjust_directions) {
m_base.readjust_directions(wraps, assigned, directions);
}
}
}
void estimate_open(
std::vector<FT_pair>& bounds,
@ -287,18 +290,20 @@ namespace Contours {
} else {
m_base.unify_along_contours_open(wraps, assigned);
m_base.correct_directions_open(wraps, assigned);
if (m_adjust_directions)
if (m_adjust_directions) {
m_base.readjust_directions(wraps, assigned, directions);
}
}
}
void set_valid_directions(
std::vector<Segment_wrapper_2>& wraps) const {
for (auto& wrap : wraps)
for (auto& wrap : wraps) {
wrap.is_valid_direction =
is_valid_principal_direction(wrap.segment);
}
}
bool is_valid_principal_direction(
const Segment_2& segment) const {
@ -327,10 +332,11 @@ namespace Contours {
do {
query_index = find_next_longest_segment(
wraps, longest_to_short);
if (query_index != std::size_t(-1))
if (query_index != std::size_t(-1)) {
set_next_longest_direction(
wraps, query_index, group_index,
bounds, directions, assigned);
}
++group_index;
} while (query_index != std::size_t(-1));
}
@ -372,8 +378,9 @@ namespace Contours {
longest.is_used = true;
for (auto& wrap : wraps) {
if (wrap.index == query_index) // skip longest
if (wrap.index == query_index) { // skip longest
continue;
}
// Check if another wrap satisifes the conditions.
if (is_valid_wrap(wrap)) {

14
Shape_regularization/include/CGAL/Shape_regularization/Contours/User_defined_directions_2.h
View File

@ -107,17 +107,19 @@ namespace Contours {
CGAL_precondition(input_range.size() >= 2);
CGAL_precondition(direction_range.size() >= 1);
if (is_closed)
if (is_closed) {
estimate_closed(
direction_range, m_bounds, m_directions, m_assigned);
else
} else {
estimate_open(
direction_range, m_bounds, m_directions, m_assigned);
}
if (verbose()) {
std::cout << "* assigned directions: ";
for (std::size_t direction_index : m_assigned)
for (std::size_t direction_index : m_assigned) {
std::cout << direction_index << " ";
}
std::cout << std::endl;
}
}
@ -203,8 +205,9 @@ namespace Contours {
initialize_directions(direction_range, directions);
bounds.clear(); bounds.reserve(directions.size());
for (std::size_t i = 0; i < directions.size(); ++i)
for (std::size_t i = 0; i < directions.size(); ++i) {
bounds.push_back(std::make_pair(FT(45), FT(45)));
}
assigned.clear(); assigned.resize(wraps.size());
set_directions(directions, wraps, assigned);
@ -229,8 +232,9 @@ namespace Contours {
initialize_directions(direction_range, directions);
bounds.clear(); bounds.reserve(directions.size());
for (std::size_t i = 0; i < directions.size(); ++i)
for (std::size_t i = 0; i < directions.size(); ++i) {
bounds.push_back(std::make_pair(FT(45), FT(45)));
}
assigned.clear(); assigned.resize(wraps.size());
set_directions(directions, wraps, assigned);

6
Shape_regularization/include/CGAL/Shape_regularization/QP_regularization.h
View File

@ -382,8 +382,9 @@ namespace Shape_regularization {
// Used to set bounds for each variable li <= xi <= ui.
const std::size_t s = m_targets.size() * 2;
for (std::size_t i = 0; i < n; ++i)
for (std::size_t i = 0; i < n; ++i) {
qp.set_A(s + i, i, FT(1));
}
// CGAL_assertion(qp.A_size() == A_nnz);
}
@ -433,8 +434,9 @@ namespace Shape_regularization {
const auto success = qp.solve(
std::back_inserter(solution));
if (!success)
if (!success) {
std::cerr << "WARNING: The solver has not converged!" << std::endl;
}
CGAL_assertion(solution.size() == n);
}
};

3
Shape_regularization/include/CGAL/Shape_regularization/Segments/Angle_regularization_2.h
View File

@ -348,9 +348,10 @@ namespace Segments {
m_num_groups = 0;
m_is_first_call = true;
m_num_modified_segments = 0;
for (auto& wrap : m_wraps)
for (auto& wrap : m_wraps) {
wrap.is_used = false;
}
}
/// @}

6
Shape_regularization/include/CGAL/Shape_regularization/Segments/Delaunay_neighbor_query_2.h
View File

@ -180,9 +180,10 @@ namespace Segments {
void clear() {
m_num_groups = 0;
m_is_first_call = true;
for (auto& group : m_groups)
for (auto& group : m_groups) {
group.clear();
}
}
/// @}
@ -194,8 +195,9 @@ namespace Segments {
std::size_t number_of_neighbors() const {
std::size_t num_neighbors = 0;
for (const auto& group : m_groups)
for (const auto& group : m_groups) {
num_neighbors += group.size();
}
return num_neighbors;
}

3
Shape_regularization/include/CGAL/Shape_regularization/Segments/Offset_regularization_2.h
View File

@ -352,9 +352,10 @@ namespace Segments {
m_num_groups = 0;
m_is_first_call = true;
m_num_modified_segments = 0;
for (auto& wrap : m_wraps)
for (auto& wrap : m_wraps) {
wrap.is_used = false;
}
}
/// @}

18
Shape_regularization/include/CGAL/Shape_regularization/internal/Closed_contour_2.h
View File

@ -62,21 +62,24 @@ namespace internal {
if (m_wraps.size() < 3) return contour;
rotate_contour(m_wraps);
if (verbose())
if (verbose()) {
m_base.export_polylines(
m_wraps, "/Users/monet/Documents/gsoc/ggr/logs/rotated");
}
bool success = optimize_contour(m_wraps);
if (!success) return contour;
if (verbose())
if (verbose()) {
m_base.export_polylines(
m_wraps, "/Users/monet/Documents/gsoc/ggr/logs/optimized");
}
success = connect_contour(m_wraps);
if (!success) return contour;
if (verbose())
if (verbose()) {
m_base.export_polylines(
m_wraps, "/Users/monet/Documents/gsoc/ggr/logs/connected");
}
return update_input(m_wraps, contour);
}
@ -112,16 +115,18 @@ namespace internal {
// Merge parallel/collinear segments.
std::vector<Segment_2> segments;
m_base.create_unique_segments(m_max_offset_2, wraps, segments);
if (verbose())
if (verbose()) {
std::cout <<
"* number of segments (merging) = " << segments.size() << std::endl;
}
if (wraps.size() < 4) return false;
// Add orthogonal segments.
create_orthogonal_segments(segments, wraps);
if (verbose())
if (verbose()) {
std::cout <<
"* number of segments (orthogonal) = " << wraps.size() << std::endl;
}
if (wraps.size() < 4) return false;
return true;
@ -219,10 +224,11 @@ namespace internal {
const std::size_t after = wraps.size();
CGAL_assertion(after <= before);
if (verbose())
if (verbose()) {
std::cout <<
"* segments before/after = " << before << "/" << after << std::endl;
}
}
template<typename OutputIterator>
OutputIterator update_input(

57
Shape_regularization/include/CGAL/Shape_regularization/internal/Contour_base_2.h
View File

@ -92,8 +92,9 @@ namespace internal {
const auto& polyline = polylines[i];
out << polyline.size() << " ";
for (std::size_t j = 0; j < polyline.size(); ++j)
for (std::size_t j = 0; j < polyline.size(); ++j) {
out << polyline[j] << " ";
}
out << std::endl;
}
save(out, path + ".polylines");
@ -133,8 +134,9 @@ namespace internal {
sorted.clear();
sorted.reserve(wraps.size());
for (std::size_t i = 0; i < wraps.size(); ++i)
for (std::size_t i = 0; i < wraps.size(); ++i) {
sorted.push_back(i);
}
std::sort(sorted.begin(), sorted.end(),
[&wraps](const std::size_t i, const std::size_t j) -> bool {
@ -243,8 +245,9 @@ namespace internal {
im = (im + n - 1) % n;
ip = (ip + 1) % n;
if (im == i || ip == i)
if (im == i || ip == i) {
stop = true;
}
++max_count;
} while (!stop && max_count < n);
@ -273,11 +276,12 @@ namespace internal {
const std::size_t di = assigned[i];
const std::size_t dp = assigned[ip];
if (dm != std::size_t(-1) && dm == dp && di != dm)
if (dm != std::size_t(-1) && dm == dp && di != dm) {
clean.push_back(dm);
else
} else {
clean.push_back(di);
}
}
assigned = clean;
}
@ -317,13 +321,16 @@ namespace internal {
}
if (stop) break;
if (im != std::size_t(-1) && im > 0)
if (im != std::size_t(-1) && im > 0) {
im = im - 1;
if (ip != std::size_t(-1) && ip < n - 1)
}
if (ip != std::size_t(-1) && ip < n - 1) {
ip = ip + 1;
}
if (im == 0 || ip == n - 1)
if (im == 0 || ip == n - 1) {
stop = true;
}
++max_count;
} while (max_count < n);
@ -351,10 +358,11 @@ namespace internal {
CGAL_assertion(ip >= 0 && ip < n);
const std::size_t di = assigned[i];
const std::size_t dp = assigned[ip];
if (di != dp)
if (di != dp) {
clean.push_back(dp);
else
} else {
clean.push_back(di);
}
continue;
}
@ -363,10 +371,11 @@ namespace internal {
CGAL_assertion(im >= 0 && im < n);
const std::size_t dm = assigned[im];
const std::size_t di = assigned[i];
if (di != dm)
if (di != dm) {
clean.push_back(dm);
else
} else {
clean.push_back(di);
}
continue;
}
@ -379,11 +388,12 @@ namespace internal {
CGAL_assertion(ip >= 0 && ip < n);
const std::size_t dp = assigned[ip];
if (dm != std::size_t(-1) && dm == dp && di != dm)
if (dm != std::size_t(-1) && dm == dp && di != dm) {
clean.push_back(dm);
else
} else {
clean.push_back(di);
}
}
assigned = clean;
}
@ -457,8 +467,9 @@ namespace internal {
query_index < assigned.size());
const std::size_t direction_index = assigned[query_index];
if (direction_index == std::size_t(-1))
if (direction_index == std::size_t(-1)) {
return;
}
CGAL_assertion(
direction_index >= 0 &&
@ -505,9 +516,11 @@ namespace internal {
std::vector<Segment_wrapper_2>& wraps) const {
std::vector<Segment_wrapper_2> clean;
for (const auto& wrap : wraps)
if (wrap.segment.squared_length() > internal::tolerance<FT>())
for (const auto& wrap : wraps) {
if (wrap.segment.squared_length() > internal::tolerance<FT>()) {
clean.push_back(wrap);
}
}
wraps = clean;
}
@ -586,8 +599,9 @@ namespace internal {
find_longest_segment(wraps);
const Segment_2 weighted =
compute_weighted_segment(wraps, weights, ref_segment);
if (weighted.source() == weighted.target())
if (weighted.source() == weighted.target()) {
return ref_segment;
}
return weighted;
}
@ -607,8 +621,9 @@ namespace internal {
}
CGAL_assertion(sum_distance > FT(0));
for (auto& weight : weights)
for (auto& weight : weights) {
weight /= sum_distance;
}
CGAL_assertion(weights.size() == wraps.size());
}
@ -744,9 +759,9 @@ namespace internal {
typename std::result_of<Intersect_2(Line_2, Line_2)>::type result
= CGAL::intersection(line_1, line_2);
if (result) {
if (const Line_2* line = boost::get<Line_2>(&*result))
if (const Line_2* line = boost::get<Line_2>(&*result)) {
return false;
else {
} else {
const Point_2* point = boost::get<Point_2>(&*result);
in_point = *point; return true;
}

21
Shape_regularization/include/CGAL/Shape_regularization/internal/Open_contour_2.h
View File

@ -62,21 +62,24 @@ namespace internal {
if (m_wraps.size() < 2) return contour;
rotate_contour(m_wraps);
if (verbose())
if (verbose()) {
m_base.export_polylines(
m_wraps, "/Users/monet/Documents/gsoc/ggr/logs/rotated");
}
bool success = optimize_contour(m_wraps);
if (!success) return contour;
if (verbose())
if (verbose()) {
m_base.export_polylines(
m_wraps, "/Users/monet/Documents/gsoc/ggr/logs/optimized");
}
success = connect_contour(m_wraps);
if (!success) return contour;
if (verbose())
if (verbose()) {
m_base.export_polylines(
m_wraps, "/Users/monet/Documents/gsoc/ggr/logs/connected");
}
return update_input(m_wraps, contour);
}
@ -112,16 +115,18 @@ namespace internal {
// Merge parallel/collinear segments.
std::vector<Segment_2> segments;
m_base.create_unique_segments(m_max_offset_2, wraps, segments);
if (verbose())
if (verbose()) {
std::cout <<
"* number of segments (merging) = " << segments.size() << std::endl;
}
if (wraps.size() < 1) return false;
// Add orthogonal segments.
create_orthogonal_segments(segments, wraps);
if (verbose())
if (verbose()) {
std::cout <<
"* number of segments (orthogonal) = " << wraps.size() << std::endl;
}
if (wraps.size() < 1) return false;
return true;
@ -189,8 +194,9 @@ namespace internal {
auto& si = wraps[i].segment;
if (im == std::size_t(-1) && ip == std::size_t(-1))
if (im == std::size_t(-1) && ip == std::size_t(-1)) {
break;
}
if (im == std::size_t(-1) && ip != std::size_t(-1)) {
const auto& sp = wraps[ip].segment;
@ -238,10 +244,11 @@ namespace internal {
const std::size_t after = wraps.size();
CGAL_assertion(after <= before);
if (verbose())
if (verbose()) {
std::cout <<
"* segments before/after = " << before << "/" << after << std::endl;
}
}
template<typename OutputIterator>
OutputIterator update_input(

6
Shape_regularization/include/CGAL/Shape_regularization/internal/Orthogonal_groups_2.h
View File

@ -101,8 +101,9 @@ namespace internal {
states[i] = true;
orthogonal_group.clear();
for (const std::size_t seg_index : parallel_groups[i])
for (const std::size_t seg_index : parallel_groups[i]) {
orthogonal_group.push_back(seg_index);
}
traverse_group(
preserve_order, i, si, parallel_groups,
@ -134,8 +135,9 @@ namespace internal {
angle_2 >= FT(90) - m_max_angle) {
states[j] = true;
for (const std::size_t seg_index : parallel_groups[j])
for (const std::size_t seg_index : parallel_groups[j]) {
orthogonal_group.push_back(seg_index);
}
} else if (preserve_order) return;
}
}

9
Shape_regularization/include/CGAL/Shape_regularization/internal/Unique_segments_2.h
View File

@ -85,8 +85,9 @@ namespace internal {
std::back_inserter(collinear_groups));
m_segments.reserve(collinear_groups.size());
for (const auto& collinear_group : collinear_groups)
for (const auto& collinear_group : collinear_groups) {
handle_collinear_group(collinear_group);
}
CGAL_assertion(m_segments.size() == collinear_groups.size());
}
@ -122,8 +123,9 @@ namespace internal {
Segment_2 weighted = compute_weighted_segment(
collinear_group, weights, ref_segment);
if (weighted.source() == weighted.target())
if (weighted.source() == weighted.target()) {
weighted = ref_segment;
}
const Vector_2 ref_vector = weighted.to_vector();
const Line_2 ref_line = Line_2(weighted.source(), weighted.target());
@ -162,8 +164,9 @@ namespace internal {
}
CGAL_assertion(sum_distance > FT(0));
for (auto& weight : weights)
for (auto& weight : weights) {
weight /= sum_distance;
}
CGAL_assertion(
weights.size() == collinear_group.size());
}

65
Shape_regularization/include/CGAL/Shape_regularization/internal/utils.h
View File

@ -181,8 +181,9 @@ namespace internal {
using FT = typename Traits::FT;
using Direction_2 = typename Traits::Direction_2;
if (v.y() < FT(0) || (v.y() == FT(0) && v.x() < FT(0)))
if (v.y() < FT(0) || (v.y() == FT(0) && v.x() < FT(0))) {
v = -v;
}
normalize_vector(v);
return Direction_2(v);
}
@ -280,8 +281,11 @@ namespace internal {
FT convert_angle_2(const FT angle_2) {
FT angle = angle_2;
if (angle > FT(90)) angle = FT(180) - angle;
else if (angle < -FT(90)) angle = FT(180) + angle;
if (angle > FT(90)) {
angle = FT(180) - angle;
} else if (angle < -FT(90)) {
angle = FT(180) + angle;
}
return angle;
}
@ -341,8 +345,11 @@ namespace internal {
Segment_2& segment) {
FT angle_deg = angle_2_deg;
if (angle_deg < FT(0)) angle_deg += ref_angle_2_deg;
else if (angle_deg > FT(0)) angle_deg -= ref_angle_2_deg;
if (angle_deg < FT(0)) {
angle_deg += ref_angle_2_deg;
} else if (angle_deg > FT(0)) {
angle_deg -= ref_angle_2_deg;
}
auto source = segment.source();
auto target = segment.target();
@ -431,10 +438,11 @@ namespace internal {
const Point pt1 = projected_origin + delta * line_vector;
const Point pt2 = projected_origin - delta * line_vector;
if (CGAL::squared_distance(pt_normal, pt1) <= CGAL::squared_distance(pt_normal, pt2))
if (CGAL::squared_distance(pt_normal, pt1) <= CGAL::squared_distance(pt_normal, pt2)) {
return Vector(CGAL::ORIGIN, pt1);
else
} else {
return Vector(CGAL::ORIGIN, pt2);
}
} else return n;
}
@ -457,8 +465,9 @@ namespace internal {
Line line;
const CGAL::Object ob_1 = CGAL::intersection(plane_orthogonality, plane_symmetry);
if (!assign(line, ob_1))
if (!assign(line, ob_1)) {
return regularize_normal<Traits>(n, symmetry_direction, cos_symmetry);
}
const Point projected_origin = line.projection(CGAL::ORIGIN);
const FT R = CGAL::squared_distance(Point(CGAL::ORIGIN), projected_origin);
@ -471,13 +480,15 @@ namespace internal {
const Point pt2 = projected_origin - delta * line_vector;
const Point pt_n = CGAL::ORIGIN + n;
if (CGAL::squared_distance(pt_n, pt1) <= CGAL::squared_distance(pt_n, pt2))
if (CGAL::squared_distance(pt_n, pt1) <= CGAL::squared_distance(pt_n, pt2)) {
return Vector(CGAL::ORIGIN, pt1);
else
} else {
return Vector(CGAL::ORIGIN, pt2);
} else // no point intersecting the unit sphere and line
}
} else { // no point intersecting the unit sphere and line
return regularize_normal<Traits>(n, symmetry_direction, cos_symmetry);
}
}
template<
typename Traits,
@ -498,10 +509,11 @@ namespace internal {
std::vector< std::vector<Point> > listp(nb_planes);
for (std::size_t i = 0; i < points.size(); ++i) {
const int idx = get(index_map, i);
if (idx != -1)
if (idx != -1) {
listp[std::size_t(idx)].push_back(
get(point_map, *(points.begin() + i)));
}
}
centroids.reserve(nb_planes);
areas.reserve(nb_planes);
@ -539,10 +551,11 @@ namespace internal {
const auto it2 = planes.begin() + j;
const Vector v2 = get(plane_map, *it2).orthogonal_vector();
if (CGAL::abs(v1 * v2) > FT(1) - tolerance_cosangle)
if (CGAL::abs(v1 * v2) > FT(1) - tolerance_cosangle) {
parallel_planes[i].push_back(j);
}
}
}
std::vector<bool> is_available(planes.size(), true);
for (std::size_t i = 0; i < std::size_t(planes.size()); ++i) {
@ -581,8 +594,9 @@ namespace internal {
index_container_current_ring_parallel.push_back(it);
is_available[it] = false;
if (clu.normal * normal_it < FT(0))
if (clu.normal * normal_it < FT(0)) {
normal_it = -normal_it;
}
clu.normal = FT(clu.area) * clu.normal + FT(areas[it]) * normal_it;
const FT norm = FT(1) / CGAL::sqrt(clu.normal.squared_length());
@ -625,8 +639,9 @@ namespace internal {
std::vector<FT> cosangle_centroids;
std::vector<std::size_t> list_cluster_index;
for (std::size_t i = 0; i < clusters.size(); ++i)
for (std::size_t i = 0; i < clusters.size(); ++i) {
list_cluster_index.push_back(static_cast<std::size_t>(-1));
}
std::size_t mean_index = 0;
for (std::size_t i = 0; i < clusters.size(); ++i) {
@ -651,15 +666,17 @@ namespace internal {
}
for (std::size_t i = 0; i < cosangle_centroids.size(); ++i) {
if (cosangle_centroids[i] < tolerance_cosangle_ortho)
if (cosangle_centroids[i] < tolerance_cosangle_ortho) {
cosangle_centroids[i] = FT(0);
else if (cosangle_centroids[i] > FT(1) - tolerance_cosangle)
} else if (cosangle_centroids[i] > FT(1) - tolerance_cosangle) {
cosangle_centroids[i] = FT(1);
}
}
for (std::size_t i = 0; i < clusters.size(); ++i)
for (std::size_t i = 0; i < clusters.size(); ++i) {
clusters[i].cosangle_symmetry = cosangle_centroids[list_cluster_index[i]];
}
}
template<typename Traits>
void subgraph_mutually_orthogonal_clusters(
@ -672,8 +689,9 @@ namespace internal {
std::vector< std::vector<std::size_t> > subgraph_clusters;
std::vector<std::size_t> subgraph_clusters_max_area_index;
for (std::size_t i = 0; i < clusters.size(); ++i)
for (std::size_t i = 0; i < clusters.size(); ++i) {
clusters[i].is_free = true;
}
for (std::size_t i = 0; i < clusters.size(); ++i) {
if (clusters[i].is_free) {
@ -736,9 +754,11 @@ namespace internal {
const std::size_t index = subgraph_clusters_max_area_index[i];
std::vector<std::size_t> subgraph_clusters_prop_temp;
for (std::size_t j = 0; j < subgraph_clusters[i].size(); ++j)
if (subgraph_clusters[i][j] != index)
for (std::size_t j = 0; j < subgraph_clusters[i].size(); ++j) {
if (subgraph_clusters[i][j] != index) {
subgraph_clusters_prop_temp.push_back(subgraph_clusters[i][j]);
}
}
subgraph_clusters_prop.push_back(subgraph_clusters_prop_temp);
}
@ -746,8 +766,9 @@ namespace internal {
// from the largest area cluster and we propagate over the subgraph
// by regularizing the normals of the clusters according to the
// orthogonality and cos angle to symmetry direction.
for (std::size_t i = 0; i < clusters.size(); ++i)
for (std::size_t i = 0; i < clusters.size(); ++i) {
clusters[i].is_free = true;
}
for (std::size_t i = 0; i < subgraph_clusters_prop.size(); ++i) {
const std::size_t index_current = subgraph_clusters_max_area_index[i];

20
Shape_regularization/include/CGAL/Shape_regularization/regularize_planes.h
View File

@ -109,9 +109,10 @@ namespace Planes {
// Find subgraphs of mutually orthogonal clusters (store indices of
// clusters in subgraph_clusters), and select the cluster of the largest area.
if (regularize_orthogonality || regularize_axis_symmetry)
if (regularize_orthogonality || regularize_axis_symmetry) {
internal::subgraph_mutually_orthogonal_clusters<Kernel>(
clusters, (regularize_axis_symmetry ? symmetry_direction : CGAL::NULL_VECTOR));
}
// Recompute optimal plane for each primitive after the normal regularization.
for (std::size_t i = 0; i < clusters.size(); ++i) {
@ -121,21 +122,24 @@ namespace Planes {
const Plane& plane = get(plane_map, *(planes.begin() + index_prim));
const Point pt_reg = plane.projection(centroids[index_prim]);
if (plane.orthogonal_vector() * vec_reg < FT(0))
if (plane.orthogonal_vector() * vec_reg < FT(0)) {
vec_reg = -vec_reg;
}
const Plane plane_reg(pt_reg, vec_reg);
if (CGAL::abs(plane.orthogonal_vector() * vec_reg) > FT(1) - tolerance_cosangle)
if (CGAL::abs(plane.orthogonal_vector() * vec_reg) > FT(1) - tolerance_cosangle) {
put(plane_map, *(planes.begin() + index_prim), plane_reg);
}
}
}
if (regularize_coplanarity) {
// Detect. co-planarity and use list_coplanar_prim to store the results.
for (std::size_t i = 0; i < clusters.size(); ++i) {
Vector vec_reg = clusters[i].normal;
for (std::size_t ip = 0; ip < clusters[i].planes.size(); ++ip)
for (std::size_t ip = 0; ip < clusters[i].planes.size(); ++ip) {
clusters[i].coplanar_group.push_back(static_cast<std::size_t>(-1));
}
std::size_t cop_index = 0;
for (std::size_t j = 0; j < clusters[i].planes.size(); ++j) {
@ -156,10 +160,11 @@ namespace Planes {
const Point pt_proj = plan_reg.projection(pt_reg_next);
const FT distance = CGAL::sqrt(CGAL::squared_distance(pt_reg_next, pt_proj));
if (distance < tolerance_coplanarity)
if (distance < tolerance_coplanarity) {
clusters[i].coplanar_group[k] = cop_index;
}
}
}
++cop_index;
}
}
@ -186,14 +191,15 @@ namespace Planes {
if (get(plane_map,
*(planes.begin() + index_prim)).orthogonal_vector()
* plane_reg.orthogonal_vector() < 0)
* plane_reg.orthogonal_vector() < 0) {
put(plane_map, *(planes.begin() + index_prim), plane_reg.opposite());
else
} else {
put(plane_map, *(planes.begin() + index_prim), plane_reg);
}
}
}
}
}
// Workaround for the bug reported here:
// https://developercommunity.visualstudio.com/content/problem/340310/unaccepted-typename-that-other-compilers-require.html

27
Shape_regularization/test/Shape_regularization/include/Saver.h
View File

@ -59,8 +59,9 @@ namespace Tests {
const FT stub = FT(0);
std::vector<Segment_2> edges;
for (const std::size_t seg_index : group)
for (const std::size_t seg_index : group) {
edges.push_back(segments[seg_index]);
}
export_segments(edges, path, stub);
}
@ -69,8 +70,9 @@ namespace Tests {
const std::string path,
const FT) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
const FT stub = FT(0);
std::vector<Segment_2> segments;
@ -92,8 +94,9 @@ namespace Tests {
const std::string path,
const FT) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
const FT stub = FT(0);
std::vector<Segment_2> segments;
@ -115,8 +118,7 @@ namespace Tests {
const std::string path,
FT scale) {
if (input.size() == 0)
return;
if (input.size() == 0) return;
clear();
// Compute barycenter.
@ -169,8 +171,9 @@ namespace Tests {
const FT scale) {
std::vector<Segment_2> edges;
for (const std::size_t seg_index : group)
for (const std::size_t seg_index : group) {
edges.push_back(segments[seg_index]);
}
export_eps_segments(edges, path, scale);
}
@ -179,8 +182,9 @@ namespace Tests {
const std::string path,
FT scale) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
std::vector<Segment_2> segments;
const std::size_t n = contour.size();
@ -201,8 +205,9 @@ namespace Tests {
const std::string path,
FT scale) {
if (contour.size() == 0)
if (contour.size() == 0) {
return;
}
std::vector<Segment_2> segments;
const std::size_t n = contour.size();
@ -244,16 +249,18 @@ namespace Tests {
const std::vector<Polyline>& polylines,
const std::string path) {
if (polylines.size() == 0)
if (polylines.size() == 0) {
return;
}
clear();
for (std::size_t i = 0; i < polylines.size(); ++i) {
const auto& polyline = polylines[i];
out << polyline.size() << " ";
for (std::size_t j = 0; j < polyline.size(); ++j)
for (std::size_t j = 0; j < polyline.size(); ++j) {
out << polyline[j] << " ";
}
out << std::endl;
}
save(path + ".polylines");

3
Shape_regularization/test/Shape_regularization/include/utils.h
View File

@ -66,8 +66,9 @@ double get_coefficient_value(
(theta > 3.0 * CGAL_PI / 2.0 && theta < 7.0 * CGAL_PI / 4.0)) {
iterator += 0.02;
} else
} else {
iterator -= 0.02;
}
if (theta < CGAL_PI) return -1.0 * iterator;
return iterator;

6
Shape_regularization/test/Shape_regularization/test_plane_regularization.cpp
View File

@ -122,9 +122,11 @@ void check_planes_changed(
const std::vector<Plane>& before,
const std::vector<Plane>& after) {
for (std::size_t i = 0; i < before.size(); ++i)
if (planes_difference(before[i], after[i]))
for (std::size_t i = 0; i < before.size(); ++i) {
if (planes_difference(before[i], after[i])) {
return;
}
}
std::cerr << "Error: no plane has been altered by regularization" <<
" while at least one should have." << std::endl;
}