3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-13 09:47:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

TriangleMesh.cpp/h:

Browse source 
New methods: has_multiple_patches(), number_of_patches()
Improved constness of file access methods.
Reduced some memory allocations costs.
Fixed some crashes of the cut() method on invalid meshes, Slic3r crashes on the unstable triangulation now.
Documented.
This commit is contained in:
bubnikv 2017-02-26 22:17:39 +01:00
parent 5b98f1a068
commit 1b89c08bfc
2 changed files with 476 additions and 335 deletions
Download patch file Download diff file Expand all files Collapse all files

671
xs/src/libslic3r/TriangleMesh.cpp
View file

@ -7,9 +7,17 @@
#include <set> #include <set>
#include <vector> #include <vector>
#include <map> #include <map>
#include <unordered_map>
#include <utility> #include <utility>
#include <algorithm> #include <algorithm>
#include <math.h> #include <math.h>
#if 0
#define DEBUG
#define _DEBUG
#undef NDEBUG
#endif
#include <assert.h> #include <assert.h>
#ifdef SLIC3R_DEBUG #ifdef SLIC3R_DEBUG
@ -91,12 +99,25 @@ TriangleMesh::TriangleMesh(const TriangleMesh &other)
} }
} }
TriangleMesh::TriangleMesh(TriangleMesh &&other) :
repaired(false)
{
stl_initialize(&this->stl);
this->swap(other);
}
TriangleMesh& TriangleMesh::operator= (TriangleMesh other) TriangleMesh& TriangleMesh::operator= (TriangleMesh other)
{ {
this->swap(other); this->swap(other);
return *this; return *this;
} }
TriangleMesh& TriangleMesh::operator=(TriangleMesh &&other)
{
this->swap(other);
return *this;
}
void void
TriangleMesh::swap(TriangleMesh &other) TriangleMesh::swap(TriangleMesh &other)
{ {
@ -109,18 +130,18 @@ TriangleMesh::~TriangleMesh() {
} }
void void
TriangleMesh::ReadSTLFile(char* input_file) { TriangleMesh::ReadSTLFile(const char* input_file) {
stl_open(&stl, input_file); stl_open(&stl, input_file);
} }
void void
TriangleMesh::write_ascii(char* output_file) TriangleMesh::write_ascii(const char* output_file)
{ {
stl_write_ascii(&this->stl, output_file, ""); stl_write_ascii(&this->stl, output_file, "");
} }
void void
TriangleMesh::write_binary(char* output_file) TriangleMesh::write_binary(const char* output_file)
{ {
stl_write_binary(&this->stl, output_file, ""); stl_write_binary(&this->stl, output_file, "");
} }
@ -314,9 +335,79 @@ void TriangleMesh::rotate(double angle, Point* center)
{ {
if (angle == 0.) if (angle == 0.)
return; return;
this->translate(-center->x, -center->y, 0); this->translate(float(-center->x), float(-center->y), 0);
stl_rotate_z(&(this->stl), (float)angle); stl_rotate_z(&(this->stl), (float)angle);
this->translate(+center->x, +center->y, 0); this->translate(float(+center->x), float(+center->y), 0);
}
bool TriangleMesh::has_multiple_patches() const
{
// we need neighbors
if (!this->repaired) CONFESS("split() requires repair()");
if (this->stl.stats.number_of_facets == 0)
return false;
std::vector<int> facet_queue(this->stl.stats.number_of_facets, 0);
std::vector<char> facet_visited(this->stl.stats.number_of_facets, false);
int facet_queue_cnt = 1;
facet_queue[0] = 0;
facet_visited[0] = true;
while (facet_queue_cnt > 0) {
int facet_idx = facet_queue[-- facet_queue_cnt];
facet_visited[facet_idx] = true;
for (int j = 0; j < 3; ++ j) {
int neighbor_idx = this->stl.neighbors_start[facet_idx].neighbor[j];
if (! facet_visited[neighbor_idx])
facet_queue[facet_queue_cnt ++] = neighbor_idx;
}
}
// If any of the face was not visited at the first time, return "multiple bodies".
for (int facet_idx = 0; facet_idx < this->stl.stats.number_of_facets; ++ facet_idx)
if (! facet_visited[facet_idx])
return true;
return false;
}
size_t TriangleMesh::number_of_patches() const
{
// we need neighbors
if (!this->repaired) CONFESS("split() requires repair()");
if (this->stl.stats.number_of_facets == 0)
return false;
std::vector<int> facet_queue(this->stl.stats.number_of_facets, 0);
std::vector<char> facet_visited(this->stl.stats.number_of_facets, false);
int facet_queue_cnt = 0;
size_t num_bodies = 0;
for (;;) {
// Find a seeding triangle for a new body.
int facet_idx = 0;
for (; facet_idx < this->stl.stats.number_of_facets; ++ facet_idx)
if (! facet_visited[facet_idx]) {
// A seed triangle was found.
facet_queue[facet_queue_cnt ++] = facet_idx;
facet_visited[facet_idx] = true;
break;
}
if (facet_idx == this->stl.stats.number_of_facets)
// No seed found.
break;
++ num_bodies;
while (facet_queue_cnt > 0) {
int facet_idx = facet_queue[-- facet_queue_cnt];
facet_visited[facet_idx] = true;
for (int j = 0; j < 3; ++ j) {
int neighbor_idx = this->stl.neighbors_start[facet_idx].neighbor[j];
if (! facet_visited[neighbor_idx])
facet_queue[facet_queue_cnt ++] = neighbor_idx;
}
}
}
return num_bodies;
} }
TriangleMeshPtrs TriangleMeshPtrs
@ -448,6 +539,57 @@ TriangleMesh::require_shared_vertices()
if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl)); if (this->stl.v_shared == NULL) stl_generate_shared_vertices(&(this->stl));
} }
TriangleMeshSlicer::TriangleMeshSlicer(TriangleMesh* _mesh) :
mesh(_mesh)
{
_mesh->require_shared_vertices();
facets_edges.assign(_mesh->stl.stats.number_of_facets * 3, -1);
v_scaled_shared.assign(_mesh->stl.v_shared, _mesh->stl.v_shared + _mesh->stl.stats.shared_vertices);
// Scale the copied vertices.
for (int i = 0; i < this->mesh->stl.stats.shared_vertices; ++ i) {
this->v_scaled_shared[i].x /= float(SCALING_FACTOR);
this->v_scaled_shared[i].y /= float(SCALING_FACTOR);
this->v_scaled_shared[i].z /= float(SCALING_FACTOR);
}
// build a table to map a facet_idx to its three edge indices
// a_id,b_id => edge_idx
struct pairhash {
std::size_t operator()(const std::pair<int, int> &x) const
{ return std::hash<int>()(x.first) ^ std::hash<int>()(x.second); }
};
std::unordered_map<std::pair<int, int>, int, pairhash> edges_map;
int num_edges = 0;
for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; ++ facet_idx) {
for (int i = 0; i < 3; ++ i) {
// Vertex indices of th ith edge of facet_idx.
int a_id = this->mesh->stl.v_indices[facet_idx].vertex[i];
int b_id = this->mesh->stl.v_indices[facet_idx].vertex[(i + 1) % 3];
int edge_idx;
auto my_edge = edges_map.find(std::make_pair(b_id, a_id));
if (my_edge == edges_map.end()) {
/* admesh can assign the same edge ID to more than two facets (which is
still topologically correct), so we have to search for a duplicate of
this edge too in case it was already seen in this orientation */
my_edge = edges_map.find(std::make_pair(a_id, b_id));
if (my_edge != edges_map.end()) {
edge_idx = my_edge->second;
} else {
// edge isn't listed in table, so we insert it
edges_map[std::make_pair(a_id, b_id)] = edge_idx = num_edges ++;
}
} else
edge_idx = my_edge->second;
this->facets_edges[facet_idx * 3 + i] = edge_idx;
#ifdef SLIC3R_TRIANGLEMESH_DEBUG
printf(" [facet %d, edge %d] a_id = %d, b_id = %d --> edge %d\n", facet_idx, i, a_id, b_id, edge_idx);
#endif
}
}
}
void void
TriangleMeshSlicer::slice(const std::vector<float> &z, std::vector<Polygons>* layers) const TriangleMeshSlicer::slice(const std::vector<float> &z, std::vector<Polygons>* layers) const
{ {
@ -499,8 +641,7 @@ TriangleMeshSlicer::slice(const std::vector<float> &z, std::vector<Polygons>* la
); );
} }
void void TriangleMeshSlicer::_slice_do(size_t facet_idx, std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex,
TriangleMeshSlicer::_slice_do(size_t facet_idx, std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex,
const std::vector<float> &z) const const std::vector<float> &z) const
{ {
const stl_facet &facet = this->mesh->stl.facet_start[facet_idx]; const stl_facet &facet = this->mesh->stl.facet_start[facet_idx];
@ -527,7 +668,31 @@ TriangleMeshSlicer::_slice_do(size_t facet_idx, std::vector<IntersectionLines>*
for (std::vector<float>::const_iterator it = min_layer; it != max_layer + 1; ++it) { for (std::vector<float>::const_iterator it = min_layer; it != max_layer + 1; ++it) {
std::vector<float>::size_type layer_idx = it - z.begin(); std::vector<float>::size_type layer_idx = it - z.begin();
this->slice_facet(*it / SCALING_FACTOR, facet, facet_idx, min_z, max_z, &(*lines)[layer_idx], lines_mutex); IntersectionLine il;
if (this->slice_facet(*it / SCALING_FACTOR, facet, facet_idx, min_z, max_z, &il)) {
boost::lock_guard<boost::mutex> l(*lines_mutex);
if (il.edge_type == feHorizontal) {
// Insert all three edges of the face.
const int *vertices = this->mesh->stl.v_indices[facet_idx].vertex;
const bool reverse = this->mesh->stl.facet_start[facet_idx].normal.z < 0;
for (int j = 0; j < 3; ++ j) {
int a_id = vertices[j % 3];
int b_id = vertices[(j+1) % 3];
if (reverse)
std::swap(a_id, b_id);
const stl_vertex *a = &this->v_scaled_shared[a_id];
const stl_vertex *b = &this->v_scaled_shared[b_id];
il.a.x = a->x;
il.a.y = a->y;
il.b.x = b->x;
il.b.y = b->y;
il.a_id = a_id;
il.b_id = b_id;
(*lines)[layer_idx].push_back(il);
}
} else
(*lines)[layer_idx].push_back(il);
}
} }
} }
@ -548,127 +713,113 @@ TriangleMeshSlicer::slice(const std::vector<float> &z, std::vector<ExPolygons>*
} }
} }
void // Return true, if the facet has been sliced and line_out has been filled.
TriangleMeshSlicer::slice_facet(float slice_z, const stl_facet &facet, const int &facet_idx, bool TriangleMeshSlicer::slice_facet(
const float &min_z, const float &max_z, std::vector<IntersectionLine>* lines, float slice_z, const stl_facet &facet, const int facet_idx,
boost::mutex* lines_mutex) const const float min_z, const float max_z,
IntersectionLine *line_out) const
{ {
std::vector<IntersectionPoint> points; IntersectionPoint points[3];
std::vector< std::vector<IntersectionPoint>::size_type > points_on_layer; size_t num_points = 0;
bool found_horizontal_edge = false; size_t points_on_layer[3];
size_t num_points_on_layer = 0;
/* reorder vertices so that the first one is the one with lowest Z // Reorder vertices so that the first one is the one with lowest Z.
this is needed to get all intersection lines in a consistent order // This is needed to get all intersection lines in a consistent order
(external on the right of the line) */ // (external on the right of the line)
int i = 0; int i = (facet.vertex[1].z == min_z) ? 1 : ((facet.vertex[2].z == min_z) ? 2 : 0);
if (facet.vertex[1].z == min_z) { for (int j = i; j - i < 3; ++ j) { // loop through facet edges
// vertex 1 has lowest Z int edge_id = this->facets_edges[facet_idx * 3 + (j % 3)];
i = 1; const int *vertices = this->mesh->stl.v_indices[facet_idx].vertex;
} else if (facet.vertex[2].z == min_z) { int a_id = vertices[j % 3];
// vertex 2 has lowest Z int b_id = vertices[(j+1) % 3];
i = 2; const stl_vertex *a = &this->v_scaled_shared[a_id];
} const stl_vertex *b = &this->v_scaled_shared[b_id];
for (int j = i; (j-i) < 3; j++) { // loop through facet edges
int edge_id = this->facets_edges[facet_idx][j % 3];
int a_id = this->mesh->stl.v_indices[facet_idx].vertex[j % 3];
int b_id = this->mesh->stl.v_indices[facet_idx].vertex[(j+1) % 3];
stl_vertex* a = &this->v_scaled_shared[a_id];
stl_vertex* b = &this->v_scaled_shared[b_id];
if (a->z == b->z && a->z == slice_z) { // Is edge or face aligned with the cutting plane?
// edge is horizontal and belongs to the current layer if (a->z == slice_z && b->z == slice_z) {
// Edge is horizontal and belongs to the current layer.
stl_vertex &v0 = this->v_scaled_shared[ this->mesh->stl.v_indices[facet_idx].vertex[0] ]; const stl_vertex &v0 = this->v_scaled_shared[vertices[0]];
stl_vertex &v1 = this->v_scaled_shared[ this->mesh->stl.v_indices[facet_idx].vertex[1] ]; const stl_vertex &v1 = this->v_scaled_shared[vertices[1]];
stl_vertex &v2 = this->v_scaled_shared[ this->mesh->stl.v_indices[facet_idx].vertex[2] ]; const stl_vertex &v2 = this->v_scaled_shared[vertices[2]];
IntersectionLine line;
if (min_z == max_z) { if (min_z == max_z) {
line.edge_type = feHorizontal; // All three vertices are aligned with slice_z.
line_out->edge_type = feHorizontal;
if (this->mesh->stl.facet_start[facet_idx].normal.z < 0) { if (this->mesh->stl.facet_start[facet_idx].normal.z < 0) {
/* if normal points downwards this is a bottom horizontal facet so we reverse // If normal points downwards this is a bottom horizontal facet so we reverse its point order.
its point order */
std::swap(a, b); std::swap(a, b);
std::swap(a_id, b_id); std::swap(a_id, b_id);
} }
} else if (v0.z < slice_z || v1.z < slice_z || v2.z < slice_z) { } else if (v0.z < slice_z || v1.z < slice_z || v2.z < slice_z) {
line.edge_type = feTop; // Two vertices are aligned with the cutting plane, the third vertex is below the cutting plane.
line_out->edge_type = feTop;
std::swap(a, b); std::swap(a, b);
std::swap(a_id, b_id); std::swap(a_id, b_id);
} else { } else {
line.edge_type = feBottom; // Two vertices are aligned with the cutting plane, the third vertex is above the cutting plane.
line_out->edge_type = feBottom;
} }
line.a.x = a->x; line_out->a.x = a->x;
line.a.y = a->y; line_out->a.y = a->y;
line.b.x = b->x; line_out->b.x = b->x;
line.b.y = b->y; line_out->b.y = b->y;
line.a_id = a_id; line_out->a_id = a_id;
line.b_id = b_id; line_out->b_id = b_id;
if (lines_mutex != NULL) { return true;
boost::lock_guard<boost::mutex> l(*lines_mutex);
lines->push_back(line);
} else {
lines->push_back(line);
} }
found_horizontal_edge = true; if (a->z == slice_z) {
// Only point a alings with the cutting plane.
// if this is a top or bottom edge, we can stop looping through edges points_on_layer[num_points_on_layer ++] = num_points;
// because we won't find anything interesting IntersectionPoint &point = points[num_points ++];
if (line.edge_type != feHorizontal) return;
} else if (a->z == slice_z) {
IntersectionPoint point;
point.x = a->x; point.x = a->x;
point.y = a->y; point.y = a->y;
point.point_id = a_id; point.point_id = a_id;
points.push_back(point);
points_on_layer.push_back(points.size()-1);
} else if (b->z == slice_z) { } else if (b->z == slice_z) {
IntersectionPoint point; // Only point b alings with the cutting plane.
points_on_layer[num_points_on_layer ++] = num_points;
IntersectionPoint &point = points[num_points ++];
point.x = b->x; point.x = b->x;
point.y = b->y; point.y = b->y;
point.point_id = b_id; point.point_id = b_id;
points.push_back(point);
points_on_layer.push_back(points.size()-1);
} else if ((a->z < slice_z && b->z > slice_z) || (b->z < slice_z && a->z > slice_z)) { } else if ((a->z < slice_z && b->z > slice_z) || (b->z < slice_z && a->z > slice_z)) {
// edge intersects the current layer; calculate intersection // A general case. The face edge intersects the cutting plane. Calculate the intersection point.
IntersectionPoint &point = points[num_points ++];
IntersectionPoint point;
point.x = b->x + (a->x - b->x) * (slice_z - b->z) / (a->z - b->z); point.x = b->x + (a->x - b->x) * (slice_z - b->z) / (a->z - b->z);
point.y = b->y + (a->y - b->y) * (slice_z - b->z) / (a->z - b->z); point.y = b->y + (a->y - b->y) * (slice_z - b->z) / (a->z - b->z);
point.edge_id = edge_id; point.edge_id = edge_id;
points.push_back(point);
} }
} }
if (found_horizontal_edge) return;
if (!points_on_layer.empty()) {
// we can't have only one point on layer because each vertex gets detected
// twice (once for each edge), and we can't have three points on layer because
// we assume this code is not getting called for horizontal facets
assert(points_on_layer.size() == 2);
assert( points[ points_on_layer[0] ].point_id == points[ points_on_layer[1] ].point_id );
if (points.size() < 3) return; // no intersection point, this is a V-shaped facet tangent to plane
points.erase( points.begin() + points_on_layer[1] );
}
if (!points.empty()) { // We can't have only one point on layer because each vertex gets detected
assert(points.size() == 2); // facets must intersect each plane 0 or 2 times // twice (once for each edge), and we can't have three points on layer,
IntersectionLine line; // because we assume this code is not getting called for horizontal facets.
line.a = (Point)points[1]; assert(num_points_on_layer == 0 || num_points_on_layer == 2);
line.b = (Point)points[0]; if (num_points_on_layer > 0) {
line.a_id = points[1].point_id; assert(points[points_on_layer[0]].point_id == points[points_on_layer[1]].point_id);
line.b_id = points[0].point_id; assert(num_points == 2 || num_points == 3);
line.edge_a_id = points[1].edge_id; if (num_points < 3)
line.edge_b_id = points[0].edge_id; // This triangle touches the cutting plane with a single vertex. Ignore it.
if (lines_mutex != NULL) { return false;
boost::lock_guard<boost::mutex> l(*lines_mutex); // Erase one of the duplicate points.
lines->push_back(line); -- num_points;
} else { for (int i = points_on_layer[1]; i < num_points; ++ i)
lines->push_back(line); points[i] = points[i + 1];
} }
return;
// Facets must intersect each plane 0 or 2 times.
assert(num_points == 0 || num_points == 2);
if (num_points == 2) {
line_out->edge_type = feNone;
line_out->a = (Point)points[1];
line_out->b = (Point)points[0];
line_out->a_id = points[1].point_id;
line_out->b_id = points[0].point_id;
line_out->edge_a_id = points[1].edge_id;
line_out->edge_b_id = points[0].edge_id;
return true;
} }
return false;
} }
void void
@ -677,28 +828,20 @@ TriangleMeshSlicer::_make_loops_do(size_t i, std::vector<IntersectionLines>* lin
this->make_loops((*lines)[i], &(*layers)[i]); this->make_loops((*lines)[i], &(*layers)[i]);
} }
void void TriangleMeshSlicer::make_loops(std::vector<IntersectionLine> &lines, Polygons* loops) const
TriangleMeshSlicer::make_loops(std::vector<IntersectionLine> &lines, Polygons* loops) const
{ {
/* // Remove tangent edges.
SVG svg("lines.svg"); //FIXME This is O(n^2) in rare cases when many faces intersect the cutting plane.
svg.draw(lines); for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++ line)
svg.Close(); if (! line->skip && line->edge_type != feNone) {
*/ // This line is af facet edge. There may be a duplicate line with the same end vertices.
// If the line is is an edge connecting two facets, find another facet edge
// remove tangent edges // having the same endpoints but in reverse order.
for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++line) { for (IntersectionLines::iterator line2 = line + 1; line2 != lines.end(); ++ line2)
if (line->skip || line->edge_type == feNone) continue; if (! line2->skip && line2->edge_type != feNone) {
// Are these facets adjacent? (sharing a common edge on this layer)
/* if the line is a facet edge, find another facet edge
having the same endpoints but in reverse order */
for (IntersectionLines::iterator line2 = line + 1; line2 != lines.end(); ++line2) {
if (line2->skip || line2->edge_type == feNone) continue;
// are these facets adjacent? (sharing a common edge on this layer)
if (line->a_id == line2->a_id && line->b_id == line2->b_id) { if (line->a_id == line2->a_id && line->b_id == line2->b_id) {
line2->skip = true; line2->skip = true;
/* if they are both oriented upwards or downwards (like a 'V') /* if they are both oriented upwards or downwards (like a 'V')
then we can remove both edges from this layer since it won't then we can remove both edges from this layer since it won't
affect the sliced shape */ affect the sliced shape */
@ -721,27 +864,33 @@ TriangleMeshSlicer::make_loops(std::vector<IntersectionLine> &lines, Polygons* l
} }
// build a map of lines by edge_a_id and a_id // build a map of lines by edge_a_id and a_id
std::vector<IntersectionLinePtrs> by_edge_a_id, by_a_id; //FIXME replace the vectors of vectors by vectors of indices to a continuous memory.
by_edge_a_id.resize(this->mesh->stl.stats.number_of_facets * 3); std::vector<IntersectionLinePtrs> by_edge_a_id(this->mesh->stl.stats.number_of_facets * 3);
by_a_id.resize(this->mesh->stl.stats.shared_vertices); std::vector<IntersectionLinePtrs> by_a_id(this->mesh->stl.stats.shared_vertices);
for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++line) { for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++ line) {
if (line->skip) continue; if (! line->skip) {
if (line->edge_a_id != -1) by_edge_a_id[line->edge_a_id].push_back(&(*line)); if (line->edge_a_id != -1)
if (line->a_id != -1) by_a_id[line->a_id].push_back(&(*line)); by_edge_a_id[line->edge_a_id].push_back(&(*line));
if (line->a_id != -1)
by_a_id[line->a_id].push_back(&(*line));
}
} }
IntersectionLines::iterator it_line_seed = lines.begin();
CYCLE: while (1) { CYCLE: while (1) {
// take first spare line and start a new loop // take first spare line and start a new loop
IntersectionLine* first_line = NULL; IntersectionLine *first_line = nullptr;
for (IntersectionLines::iterator line = lines.begin(); line != lines.end(); ++line) { for (; it_line_seed != lines.end(); ++ it_line_seed)
if (line->skip) continue; if (! it_line_seed->skip) {
first_line = &(*line); first_line = &(*it_line_seed ++);
break; break;
} }
if (first_line == NULL) break; if (first_line == nullptr)
break;
first_line->skip = true; first_line->skip = true;
IntersectionLinePtrs loop; Points loop_pts;
loop.push_back(first_line); loop_pts.push_back(first_line->a);
IntersectionLine *last_line = first_line;
/* /*
printf("first_line edge_a_id = %d, edge_b_id = %d, a_id = %d, b_id = %d, a = %d,%d, b = %d,%d\n", printf("first_line edge_a_id = %d, edge_b_id = %d, a_id = %d, b_id = %d, a = %d,%d, b = %d,%d\n",
@ -749,50 +898,40 @@ TriangleMeshSlicer::make_loops(std::vector<IntersectionLine> &lines, Polygons* l
first_line->a.x, first_line->a.y, first_line->b.x, first_line->b.y); first_line->a.x, first_line->a.y, first_line->b.x, first_line->b.y);
*/ */
while (1) { for (;;) {
// find a line starting where last one finishes // find a line starting where last one finishes
IntersectionLine* next_line = NULL; IntersectionLine* next_line = nullptr;
if (loop.back()->edge_b_id != -1) { if (last_line->edge_b_id != -1) {
IntersectionLinePtrs &candidates = by_edge_a_id[loop.back()->edge_b_id]; IntersectionLinePtrs &candidates = by_edge_a_id[last_line->edge_b_id];
for (IntersectionLinePtrs::iterator lineptr = candidates.begin(); lineptr != candidates.end(); ++lineptr) { for (IntersectionLinePtrs::iterator lineptr = candidates.begin(); lineptr != candidates.end(); ++ lineptr)
if ((*lineptr)->skip) continue; if (! (*lineptr)->skip) {
next_line = *lineptr; next_line = *lineptr;
break; break;
} }
} }
if (next_line == NULL && loop.back()->b_id != -1) { if (next_line == nullptr && last_line->b_id != -1) {
IntersectionLinePtrs &candidates = by_a_id[loop.back()->b_id]; IntersectionLinePtrs &candidates = by_a_id[last_line->b_id];
for (IntersectionLinePtrs::iterator lineptr = candidates.begin(); lineptr != candidates.end(); ++lineptr) { for (IntersectionLinePtrs::iterator lineptr = candidates.begin(); lineptr != candidates.end(); ++ lineptr)
if ((*lineptr)->skip) continue; if (! (*lineptr)->skip) {
next_line = *lineptr; next_line = *lineptr;
break; break;
} }
} }
if (next_line == nullptr) {
if (next_line == NULL) {
// check whether we closed this loop // check whether we closed this loop
if ((loop.front()->edge_a_id != -1 && loop.front()->edge_a_id == loop.back()->edge_b_id) if ((first_line->edge_a_id != -1 && first_line->edge_a_id == last_line->edge_b_id) ||
|| (loop.front()->a_id != -1 && loop.front()->a_id == loop.back()->b_id)) { (first_line->a_id != -1 && first_line->a_id == last_line->b_id)) {
// loop is complete // loop is complete
Polygon p; loops->emplace_back(std::move(loop_pts));
p.points.reserve(loop.size());
for (IntersectionLinePtrs::const_iterator lineptr = loop.begin(); lineptr != loop.end(); ++lineptr) {
p.points.push_back((*lineptr)->a);
}
loops->push_back(p);
#ifdef SLIC3R_TRIANGLEMESH_DEBUG #ifdef SLIC3R_TRIANGLEMESH_DEBUG
printf(" Discovered %s polygon of %d points\n", (p.is_counter_clockwise() ? "ccw" : "cw"), (int)p.points.size()); printf(" Discovered %s polygon of %d points\n", (p.is_counter_clockwise() ? "ccw" : "cw"), (int)p.points.size());
#endif #endif
goto CYCLE; goto CYCLE;
} }
// we can't close this loop! // we can't close this loop!
//// push @failed_loops, [@loop]; //// push @failed_loops, [@loop];
//#ifdef SLIC3R_TRIANGLEMESH_DEBUG //#ifdef SLIC3R_TRIANGLEMESH_DEBUG
printf(" Unable to close this loop having %d points\n", (int)loop.size()); printf(" Unable to close this loop having %d points\n", (int)loop_pts.size());
//#endif //#endif
goto CYCLE; goto CYCLE;
} }
@ -801,59 +940,95 @@ TriangleMeshSlicer::make_loops(std::vector<IntersectionLine> &lines, Polygons* l
next_line->edge_a_id, next_line->edge_b_id, next_line->a_id, next_line->b_id, next_line->edge_a_id, next_line->edge_b_id, next_line->a_id, next_line->b_id,
next_line->a.x, next_line->a.y, next_line->b.x, next_line->b.y); next_line->a.x, next_line->a.y, next_line->b.x, next_line->b.y);
*/ */
loop.push_back(next_line); loop_pts.push_back(next_line->a);
last_line = next_line;
next_line->skip = true; next_line->skip = true;
} }
} }
} }
class _area_comp { // Only used to cut the mesh into two halves.
public: void TriangleMeshSlicer::make_expolygons_simple(std::vector<IntersectionLine> &lines, ExPolygons* slices) const
_area_comp(std::vector<double>* _aa) : abs_area(_aa) {};
bool operator() (const size_t &a, const size_t &b) {
return (*this->abs_area)[a] > (*this->abs_area)[b];
}
private:
std::vector<double>* abs_area;
};
void
TriangleMeshSlicer::make_expolygons_simple(std::vector<IntersectionLine> &lines, ExPolygons* slices) const
{ {
assert(slices->empty());
Polygons loops; Polygons loops;
this->make_loops(lines, &loops); this->make_loops(lines, &loops);
Polygons cw; Polygons holes;
for (Polygons::const_iterator loop = loops.begin(); loop != loops.end(); ++loop) { for (Polygons::const_iterator loop = loops.begin(); loop != loops.end(); ++ loop) {
if (loop->area() >= 0) { if (loop->area() >= 0.) {
ExPolygon ex; ExPolygon ex;
ex.contour = *loop; ex.contour = *loop;
slices->push_back(ex); slices->push_back(ex);
} else { } else {
cw.push_back(*loop); holes.push_back(*loop);
} }
} }
// assign holes to contours // If there are holes, then there should also be outer contours.
for (Polygons::const_iterator loop = cw.begin(); loop != cw.end(); ++loop) { assert(holes.empty() || ! slices->empty());
if (slices->empty())
return;
// Assign holes to outer contours.
for (Polygons::const_iterator hole = holes.begin(); hole != holes.end(); ++ hole) {
// Find an outer contour to a hole.
int slice_idx = -1; int slice_idx = -1;
double current_contour_area = -1; double current_contour_area = std::numeric_limits<double>::max();
for (ExPolygons::iterator slice = slices->begin(); slice != slices->end(); ++slice) { for (ExPolygons::iterator slice = slices->begin(); slice != slices->end(); ++ slice) {
if (slice->contour.contains(loop->points.front())) { if (slice->contour.contains(hole->points.front())) {
double area = slice->contour.area(); double area = slice->contour.area();
if (area < current_contour_area || current_contour_area == -1) { if (area < current_contour_area) {
slice_idx = slice - slices->begin(); slice_idx = slice - slices->begin();
current_contour_area = area; current_contour_area = area;
} }
} }
} }
(*slices)[slice_idx].holes.push_back(*loop); // assert(slice_idx != -1);
if (slice_idx == -1)
// Ignore this hole.
continue;
assert(current_contour_area < std::numeric_limits<double>::max() && current_contour_area >= -hole->area());
(*slices)[slice_idx].holes.emplace_back(std::move(*hole));
} }
#if 0
// If the input mesh is not valid, the holes may intersect with the external contour.
// Rather subtract them from the outer contour.
Polygons poly;
for (auto it_slice = slices->begin(); it_slice != slices->end(); ++ it_slice) {
if (it_slice->holes.empty()) {
poly.emplace_back(std::move(it_slice->contour));
} else {
Polygons contours;
contours.emplace_back(std::move(it_slice->contour));
for (auto it = it_slice->holes.begin(); it != it_slice->holes.end(); ++ it)
it->reverse();
polygons_append(poly, diff(contours, it_slice->holes));
}
}
// If the input mesh is not valid, the input contours may intersect.
*slices = union_ex(poly);
#endif
#if 0
// If the input mesh is not valid, the holes may intersect with the external contour.
// Rather subtract them from the outer contour.
ExPolygons poly;
for (auto it_slice = slices->begin(); it_slice != slices->end(); ++ it_slice) {
Polygons contours;
contours.emplace_back(std::move(it_slice->contour));
for (auto it = it_slice->holes.begin(); it != it_slice->holes.end(); ++ it)
it->reverse();
expolygons_append(poly, diff_ex(contours, it_slice->holes));
}
// If the input mesh is not valid, the input contours may intersect.
*slices = std::move(poly);
#endif
} }
void void TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) const
TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) const
{ {
/* /*
Input loops are not suitable for evenodd nor nonzero fill types, as we might get Input loops are not suitable for evenodd nor nonzero fill types, as we might get
@ -873,20 +1048,19 @@ TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) c
*/ */
std::vector<double> area; std::vector<double> area;
std::vector<double> abs_area;
std::vector<size_t> sorted_area; // vector of indices std::vector<size_t> sorted_area; // vector of indices
for (Polygons::const_iterator loop = loops.begin(); loop != loops.end(); ++loop) { for (Polygons::const_iterator loop = loops.begin(); loop != loops.end(); ++ loop) {
double a = loop->area(); area.push_back(loop->area());
area.push_back(a);
abs_area.push_back(std::fabs(a));
sorted_area.push_back(loop - loops.begin()); sorted_area.push_back(loop - loops.begin());
} }
std::sort(sorted_area.begin(), sorted_area.end(), _area_comp(&abs_area)); // outer first // outer first
std::sort(sorted_area.begin(), sorted_area.end(),
[&area](size_t a, size_t b) { return std::abs(area[a]) > std::abs(area[b]); });
// we don't perform a safety offset now because it might reverse cw loops // we don't perform a safety offset now because it might reverse cw loops
Polygons p_slices; Polygons p_slices;
for (std::vector<size_t>::const_iterator loop_idx = sorted_area.begin(); loop_idx != sorted_area.end(); ++loop_idx) { for (std::vector<size_t>::const_iterator loop_idx = sorted_area.begin(); loop_idx != sorted_area.end(); ++ loop_idx) {
/* we rely on the already computed area to determine the winding order /* we rely on the already computed area to determine the winding order
of the loops, since the Orientation() function provided by Clipper of the loops, since the Orientation() function provided by Clipper
would do the same, thus repeating the calculation */ would do the same, thus repeating the calculation */
@ -894,6 +1068,11 @@ TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) c
if (area[*loop_idx] > +EPSILON) if (area[*loop_idx] > +EPSILON)
p_slices.push_back(*loop); p_slices.push_back(*loop);
else if (area[*loop_idx] < -EPSILON) else if (area[*loop_idx] < -EPSILON)
//FIXME This is arbitrary and possibly very slow.
// If the hole is inside a polygon, then there is no need to diff.
// If the hole intersects a polygon boundary, then diff it, but then
// there is no guarantee of an ordering of the loops.
// Maybe we can test for the intersection before running the expensive diff algorithm?
p_slices = diff(p_slices, *loop); p_slices = diff(p_slices, *loop);
} }
@ -903,9 +1082,8 @@ TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) c
#ifdef SLIC3R_TRIANGLEMESH_DEBUG #ifdef SLIC3R_TRIANGLEMESH_DEBUG
size_t holes_count = 0; size_t holes_count = 0;
for (ExPolygons::const_iterator e = ex_slices.begin(); e != ex_slices.end(); ++e) { for (ExPolygons::const_iterator e = ex_slices.begin(); e != ex_slices.end(); ++ e)
holes_count += e->holes.size(); holes_count += e->holes.size();
}
printf(PRINTF_ZU " surface(s) having " PRINTF_ZU " holes detected from " PRINTF_ZU " polylines\n", printf(PRINTF_ZU " surface(s) having " PRINTF_ZU " holes detected from " PRINTF_ZU " polylines\n",
ex_slices.size(), holes_count, loops.size()); ex_slices.size(), holes_count, loops.size());
#endif #endif
@ -914,51 +1092,47 @@ TriangleMeshSlicer::make_expolygons(const Polygons &loops, ExPolygons* slices) c
expolygons_append(*slices, ex_slices); expolygons_append(*slices, ex_slices);
} }
void void TriangleMeshSlicer::make_expolygons(std::vector<IntersectionLine> &lines, ExPolygons* slices) const
TriangleMeshSlicer::make_expolygons(std::vector<IntersectionLine> &lines, ExPolygons* slices) const
{ {
Polygons pp; Polygons pp;
this->make_loops(lines, &pp); this->make_loops(lines, &pp);
this->make_expolygons(pp, slices); this->make_expolygons(pp, slices);
} }
void void TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower) const
TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower) const
{ {
IntersectionLines upper_lines, lower_lines; IntersectionLines upper_lines, lower_lines;
float scaled_z = scale_(z); float scaled_z = scale_(z);
for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; facet_idx++) { for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; ++ facet_idx) {
stl_facet* facet = &this->mesh->stl.facet_start[facet_idx]; stl_facet* facet = &this->mesh->stl.facet_start[facet_idx];
// find facet extents // find facet extents
float min_z = fminf(facet->vertex[0].z, fminf(facet->vertex[1].z, facet->vertex[2].z)); float min_z = std::min(facet->vertex[0].z, std::min(facet->vertex[1].z, facet->vertex[2].z));
float max_z = fmaxf(facet->vertex[0].z, fmaxf(facet->vertex[1].z, facet->vertex[2].z)); float max_z = std::max(facet->vertex[0].z, std::max(facet->vertex[1].z, facet->vertex[2].z));
// intersect facet with cutting plane // intersect facet with cutting plane
IntersectionLines lines; IntersectionLine line;
this->slice_facet(scaled_z, *facet, facet_idx, min_z, max_z, &lines); if (this->slice_facet(scaled_z, *facet, facet_idx, min_z, max_z, &line)) {
// Save intersection lines for generating correct triangulations.
// save intersection lines for generating correct triangulations if (line.edge_type == feTop) {
for (IntersectionLines::const_iterator it = lines.begin(); it != lines.end(); ++it) { lower_lines.push_back(line);
if (it->edge_type == feTop) { } else if (line.edge_type == feBottom) {
lower_lines.push_back(*it); upper_lines.push_back(line);
} else if (it->edge_type == feBottom) { } else if (line.edge_type != feHorizontal) {
upper_lines.push_back(*it); lower_lines.push_back(line);
} else if (it->edge_type != feHorizontal) { upper_lines.push_back(line);
lower_lines.push_back(*it);
upper_lines.push_back(*it);
} }
} }
if (min_z > z || (min_z == z && max_z > min_z)) { if (min_z > z || (min_z == z && max_z > z)) {
// facet is above the cut plane and does not belong to it // facet is above the cut plane and does not belong to it
if (upper != NULL) stl_add_facet(&upper->stl, facet); if (upper != NULL) stl_add_facet(&upper->stl, facet);
} else if (max_z < z || (max_z == z && max_z > min_z)) { } else if (max_z < z || (max_z == z && min_z < z)) {
// facet is below the cut plane and does not belong to it // facet is below the cut plane and does not belong to it
if (lower != NULL) stl_add_facet(&lower->stl, facet); if (lower != NULL) stl_add_facet(&lower->stl, facet);
} else if (min_z < z && max_z > z) { } else if (min_z < z && max_z > z) {
// facet is cut by the slicing plane // Facet is cut by the slicing plane.
// look for the vertex on whose side of the slicing plane there are no other vertices // look for the vertex on whose side of the slicing plane there are no other vertices
int isolated_vertex; int isolated_vertex;
@ -1072,74 +1246,11 @@ TriangleMeshSlicer::cut(float z, TriangleMesh* upper, TriangleMesh* lower) const
} }
} }
// Update the bounding box / sphere of the new meshes.
stl_get_size(&(upper->stl)); stl_get_size(&upper->stl);
stl_get_size(&(lower->stl)); stl_get_size(&lower->stl);
} }
TriangleMeshSlicer::TriangleMeshSlicer(TriangleMesh* _mesh) : mesh(_mesh), v_scaled_shared(NULL)
{
// build a table to map a facet_idx to its three edge indices
this->mesh->require_shared_vertices();
typedef std::pair<int,int> t_edge;
typedef std::vector<t_edge> t_edges; // edge_idx => a_id,b_id
typedef std::map<t_edge,int> t_edges_map; // a_id,b_id => edge_idx
this->facets_edges.resize(this->mesh->stl.stats.number_of_facets);
{
t_edges edges;
// reserve() instad of resize() because otherwise we couldn't read .size() below to assign edge_idx
edges.reserve(this->mesh->stl.stats.number_of_facets * 3); // number of edges = number of facets * 3
t_edges_map edges_map;
for (int facet_idx = 0; facet_idx < this->mesh->stl.stats.number_of_facets; facet_idx++) {
this->facets_edges[facet_idx].resize(3);
for (int i = 0; i <= 2; i++) {
int a_id = this->mesh->stl.v_indices[facet_idx].vertex[i];
int b_id = this->mesh->stl.v_indices[facet_idx].vertex[(i+1) % 3];
int edge_idx;
t_edges_map::const_iterator my_edge = edges_map.find(std::make_pair(b_id,a_id));
if (my_edge != edges_map.end()) {
edge_idx = my_edge->second;
} else {
/* admesh can assign the same edge ID to more than two facets (which is
still topologically correct), so we have to search for a duplicate of
this edge too in case it was already seen in this orientation */
my_edge = edges_map.find(std::make_pair(a_id,b_id));
if (my_edge != edges_map.end()) {
edge_idx = my_edge->second;
} else {
// edge isn't listed in table, so we insert it
edge_idx = edges.size();
edges.push_back(std::make_pair(a_id,b_id));
edges_map[ edges[edge_idx] ] = edge_idx;
}
}
this->facets_edges[facet_idx][i] = edge_idx;
#ifdef SLIC3R_TRIANGLEMESH_DEBUG
printf(" [facet %d, edge %d] a_id = %d, b_id = %d --> edge %d\n", facet_idx, i, a_id, b_id, edge_idx);
#endif
}
}
}
// clone shared vertices coordinates and scale them
this->v_scaled_shared = (stl_vertex*)calloc(this->mesh->stl.stats.shared_vertices, sizeof(stl_vertex));
std::copy(this->mesh->stl.v_shared, this->mesh->stl.v_shared + this->mesh->stl.stats.shared_vertices, this->v_scaled_shared);
for (int i = 0; i < this->mesh->stl.stats.shared_vertices; i++) {
this->v_scaled_shared[i].x /= SCALING_FACTOR;
this->v_scaled_shared[i].y /= SCALING_FACTOR;
this->v_scaled_shared[i].z /= SCALING_FACTOR;
}
}
TriangleMeshSlicer::~TriangleMeshSlicer()
{
if (this->v_scaled_shared != NULL) free(this->v_scaled_shared);
}
// Generate the vertex list for a cube solid of arbitrary size in X/Y/Z. // Generate the vertex list for a cube solid of arbitrary size in X/Y/Z.
TriangleMesh make_cube(double x, double y, double z) { TriangleMesh make_cube(double x, double y, double z) {
Pointf3 pv[8] = { Pointf3 pv[8] = {

70
xs/src/libslic3r/TriangleMesh.hpp
View file

@ -19,16 +19,18 @@ typedef std::vector<TriangleMesh*> TriangleMeshPtrs;
class TriangleMesh class TriangleMesh
{ {
public: public:
TriangleMesh(); TriangleMesh();
TriangleMesh(const Pointf3s &points, const std::vector<Point3> &facets); TriangleMesh(const Pointf3s &points, const std::vector<Point3> &facets);
TriangleMesh(const TriangleMesh &other); TriangleMesh(const TriangleMesh &other);
TriangleMesh(TriangleMesh &&other);
TriangleMesh& operator= (TriangleMesh other); TriangleMesh& operator= (TriangleMesh other);
TriangleMesh& operator= (TriangleMesh &&other);
void swap(TriangleMesh &other); void swap(TriangleMesh &other);
~TriangleMesh(); ~TriangleMesh();
void ReadSTLFile(char* input_file); void ReadSTLFile(const char* input_file);
void write_ascii(char* output_file); void write_ascii(const char* output_file);
void write_binary(char* output_file); void write_binary(const char* output_file);
void repair(); void repair();
void WriteOBJFile(char* output_file); void WriteOBJFile(char* output_file);
void scale(float factor); void scale(float factor);
@ -52,32 +54,60 @@ class TriangleMesh
void reset_repair_stats(); void reset_repair_stats();
bool needed_repair() const; bool needed_repair() const;
size_t facets_count() const; size_t facets_count() const;
// Returns true, if there are two and more connected patches in the mesh.
// Returns false, if one or zero connected patch is in the mesh.
bool has_multiple_patches() const;
// Count disconnected triangle patches.
size_t number_of_patches() const;
stl_file stl; stl_file stl;
bool repaired; bool repaired;
private: private:
void require_shared_vertices(); void require_shared_vertices();
friend class TriangleMeshSlicer; friend class TriangleMeshSlicer;
}; };
enum FacetEdgeType { feNone, feTop, feBottom, feHorizontal }; enum FacetEdgeType {
// A general case, the cutting plane intersect a face at two different edges.
feNone,
// Two vertices are aligned with the cutting plane, the third vertex is below the cutting plane.
feTop,
// Two vertices are aligned with the cutting plane, the third vertex is above the cutting plane.
feBottom,
// All three vertices of a face are aligned with the cutting plane.
feHorizontal
};
class IntersectionPoint : public Point class IntersectionPoint : public Point
{ {
public: public:
int point_id;
int edge_id;
IntersectionPoint() : point_id(-1), edge_id(-1) {}; IntersectionPoint() : point_id(-1), edge_id(-1) {};
// Inherits coord_t x, y
// Where is this intersection point located? On mesh vertex or mesh edge?
// Only one of the following will be set, the other will remain set to -1.
// Index of the mesh vertex.
int point_id;
// Index of the mesh edge.
int edge_id;
}; };
class IntersectionLine : public Line class IntersectionLine : public Line
{ {
public: public:
// Inherits Point a, b
// For each line end point, either {a,b}_id or {a,b}edge_a_id is set, the other is left to -1.
// Vertex indices of the line end points.
int a_id; int a_id;
int b_id; int b_id;
// Source mesh edges of the line end points.
int edge_a_id; int edge_a_id;
int edge_b_id; int edge_b_id;
// feNone, feTop, feBottom, feHorizontal
FacetEdgeType edge_type; FacetEdgeType edge_type;
// Used by TriangleMeshSlicer::make_loops() to skip duplicate edges.
bool skip; bool skip;
IntersectionLine() : a_id(-1), b_id(-1), edge_a_id(-1), edge_b_id(-1), edge_type(feNone), skip(false) {}; IntersectionLine() : a_id(-1), b_id(-1), edge_a_id(-1), edge_b_id(-1), edge_type(feNone), skip(false) {};
}; };
@ -86,21 +116,21 @@ typedef std::vector<IntersectionLine*> IntersectionLinePtrs;
class TriangleMeshSlicer class TriangleMeshSlicer
{ {
public: public:
TriangleMesh* mesh;
TriangleMeshSlicer(TriangleMesh* _mesh); TriangleMeshSlicer(TriangleMesh* _mesh);
~TriangleMeshSlicer();
void slice(const std::vector<float> &z, std::vector<Polygons>* layers) const; void slice(const std::vector<float> &z, std::vector<Polygons>* layers) const;
void slice(const std::vector<float> &z, std::vector<ExPolygons>* layers) const; void slice(const std::vector<float> &z, std::vector<ExPolygons>* layers) const;
void slice_facet(float slice_z, const stl_facet &facet, const int &facet_idx, bool slice_facet(float slice_z, const stl_facet &facet, const int facet_idx,
const float &min_z, const float &max_z, std::vector<IntersectionLine>* lines, const float min_z, const float max_z, IntersectionLine *line_out) const;
boost::mutex* lines_mutex = NULL) const;
void cut(float z, TriangleMesh* upper, TriangleMesh* lower) const; void cut(float z, TriangleMesh* upper, TriangleMesh* lower) const;
private: private:
typedef std::vector< std::vector<int> > t_facets_edges; const TriangleMesh *mesh;
t_facets_edges facets_edges; // Map from a facet to an edge index.
stl_vertex* v_scaled_shared; std::vector<int> facets_edges;
// Scaled copy of this->mesh->stl.v_shared
std::vector<stl_vertex> v_scaled_shared;
void _slice_do(size_t facet_idx, std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex, const std::vector<float> &z) const; void _slice_do(size_t facet_idx, std::vector<IntersectionLines>* lines, boost::mutex* lines_mutex, const std::vector<float> &z) const;
void _make_loops_do(size_t i, std::vector<IntersectionLines>* lines, std::vector<Polygons>* layers) const; void _make_loops_do(size_t i, std::vector<IntersectionLines>* lines, std::vector<Polygons>* layers) const;
void make_loops(std::vector<IntersectionLine> &lines, Polygons* loops) const; void make_loops(std::vector<IntersectionLine> &lines, Polygons* loops) const;