CGAL 6.1 - Shape Regularization

Loading...
Searching...
No Matches
Shape_regularization/regularize_15_segments.cpp
#include "include/utils.h"
#include "include/Saver.h"
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Shape_regularization.h>
// Typedefs.
using Kernel = CGAL::Exact_predicates_inexact_constructions_kernel;
using FT = typename Kernel::FT;
using Segment_2 = typename Kernel::Segment_2;
using Segments = std::vector<Segment_2>;
using Indices = std::vector<std::size_t>;
using Segment_map = CGAL::Identity_property_map<Segment_2>;
using Neighbor_query =
CGAL::Shape_regularization::Segments::Delaunay_neighbor_query_2<Kernel, Segments, Segment_map>;
using Angle_regularization =
CGAL::Shape_regularization::Segments::Angle_regularization_2<Kernel, Segments, Segment_map>;
using Offset_regularization =
CGAL::Shape_regularization::Segments::Offset_regularization_2<Kernel, Segments, Segment_map>;
using Quadratic_program =
CGAL::OSQP_quadratic_program_traits<FT>;
using Quadratic_angle_regularizer =
CGAL::Shape_regularization::QP_regularization<
Kernel, Segments, Neighbor_query, Angle_regularization, Quadratic_program>;
using Quadratic_offset_regularizer =
CGAL::Shape_regularization::QP_regularization<
Kernel, Segments, Neighbor_query, Offset_regularization, Quadratic_program>;
int main(int argc, char *argv[]) {
// If we want to save the result in a file, we save it in a path.
std::string path = "";
if (argc > 1) path = argv[1];
Saver<Kernel> saver;
// Initialize 15 segments.
std::vector<Segment_2> segments;
create_example_15(segments);
// We create three groups of segments:
// outer, top and bottom rhombuses.
std::vector<Indices> groups(3);
groups[0] = {0, 1, 2, 3, 4, 5, 6}; // outer
groups[1] = {7, 8, 9, 10}; // top rhombus
groups[2] = {11, 12, 13, 14}; // bottom rhombus
// Save input segments.
if (path != "") {
const std::string full_path = path + "regularize_15_segments_before";
saver.export_eps_segments(segments, full_path, FT(100));
}
// Angle regularization.
const FT max_angle_2 = FT(10);
// Create qp solver, neighbor query, and angle-based regularization model.
Quadratic_program qp_angles;
Neighbor_query neighbor_query(segments);
Angle_regularization angle_regularization(
segments, CGAL::parameters::maximum_angle(max_angle_2));
// Add each group of input segments.
for (const auto& group : groups) {
neighbor_query.add_group(group);
angle_regularization.add_group(group);
}
// Regularize.
Quadratic_angle_regularizer qp_angle_regularizer(
segments, neighbor_query, angle_regularization, qp_angles);
qp_angle_regularizer.regularize();
std::cout << "* number of modified segments (angles) = " <<
angle_regularization.number_of_modified_segments() << std::endl;
// Offset regularization.
const FT max_offset_2 = FT(1) / FT(10);
// Get groups of parallel segments after angle regularization.
std::vector<Indices> pgroups;
angle_regularization.parallel_groups(
std::back_inserter(pgroups));
// Create qp solver and offset-based regularization model.
Quadratic_program qp_offsets;
Offset_regularization offset_regularization(
segments, CGAL::parameters::maximum_offset(max_offset_2));
// Add each group of parallel segments with at least 2 segments.
neighbor_query.clear();
for (const auto& pgroup : pgroups) {
neighbor_query.add_group(pgroup);
offset_regularization.add_group(pgroup);
}
// Regularize.
Quadratic_offset_regularizer qp_offset_regularizer(
segments, neighbor_query, offset_regularization, qp_offsets);
qp_offset_regularizer.regularize();
std::cout << "* number of modified segments (offsets) = " <<
offset_regularization.number_of_modified_segments() << std::endl;
// Save regularized segments.
if (path != "") {
const std::string full_path = path + "regularize_15_segments_after";
saver.export_eps_segments(segments, full_path, FT(100));
}
}
Shape_regularization.h
A convenience header that includes all free functions and classes for shape regularization.
CGAL::Exact_predicates_inexact_constructions_kernel
CGAL::OSQP_quadratic_program_traits
CGAL::Shape_regularization::QP_regularization
Shape regularization algorithm based on the quadratic programming global optimization.
Definition: QP_regularization.h:70
CGAL::Shape_regularization::Segments::Angle_regularization_2
An angle-based regularization type for 2D segments that reinforces parallelism and orthogonality rela...
Definition: Angle_regularization_2.h:55
CGAL::Shape_regularization::Segments::Delaunay_neighbor_query_2
A neighbor query based on a Delaunay triangulation, which enables to find the nearest neighbors in a ...
Definition: Delaunay_neighbor_query_2.h:61
CGAL::Shape_regularization::Segments::Offset_regularization_2
An offset-based regularization type for 2D segments that reinforces collinearity relationships.
Definition: Offset_regularization_2.h:60
Kernel::Segment_2
Kernel
CGAL::Identity_property_map