4e11552da9
Fixes Connecting / expanding Bottom Layers to Vase Perimeter #253 Fixes Slicing error in vase mode #452 Fixes Slicing Issue (Vase Mode, 0.6mm dmr nozzle) #1887 Fixes Top fill pattern isn't used in spiral vase mode #2533 Fixes Cisar's vase doesn't slice correctly, creates artefacts #3595 When the model is sliced, all the contours are newly oriented counter-clockwise (even holes), merged and then only the largest area contour is retained. In perimeter generator, if the largest contour splits into multiple perimeters, newly only the largest area perimeter is retained in spiral vase mode. These two changes solve #3595 and similar. The infill is newly calculated only for the bottom solid layers if the spiral vase mode is active (removes various unwanted infill along the vase walls), and the last bottom solid layer is switched to a top solid pattern (solves #2533). The thin walls are newly enforced to be disabled in spiral vase mode, and the "ensure vertical shell wall" is enforced in spiral vase mode to extend the bottom of the vase to the vase hull (fixes #253).
514 lines
26 KiB
C++
514 lines
26 KiB
C++
#include "PerimeterGenerator.hpp"
|
||
#include "ClipperUtils.hpp"
|
||
#include "ExtrusionEntityCollection.hpp"
|
||
#include "ShortestPath.hpp"
|
||
|
||
#include <cmath>
|
||
#include <cassert>
|
||
|
||
namespace Slic3r {
|
||
|
||
static ExtrusionPaths thick_polyline_to_extrusion_paths(const ThickPolyline &thick_polyline, ExtrusionRole role, Flow &flow, const float tolerance)
|
||
{
|
||
ExtrusionPaths paths;
|
||
ExtrusionPath path(role);
|
||
ThickLines lines = thick_polyline.thicklines();
|
||
|
||
for (int i = 0; i < (int)lines.size(); ++i) {
|
||
const ThickLine& line = lines[i];
|
||
|
||
const coordf_t line_len = line.length();
|
||
if (line_len < SCALED_EPSILON) continue;
|
||
|
||
double thickness_delta = fabs(line.a_width - line.b_width);
|
||
if (thickness_delta > tolerance) {
|
||
const unsigned int segments = (unsigned int)ceil(thickness_delta / tolerance);
|
||
const coordf_t seg_len = line_len / segments;
|
||
Points pp;
|
||
std::vector<coordf_t> width;
|
||
{
|
||
pp.push_back(line.a);
|
||
width.push_back(line.a_width);
|
||
for (size_t j = 1; j < segments; ++j) {
|
||
pp.push_back((line.a.cast<double>() + (line.b - line.a).cast<double>().normalized() * (j * seg_len)).cast<coord_t>());
|
||
|
||
coordf_t w = line.a_width + (j*seg_len) * (line.b_width-line.a_width) / line_len;
|
||
width.push_back(w);
|
||
width.push_back(w);
|
||
}
|
||
pp.push_back(line.b);
|
||
width.push_back(line.b_width);
|
||
|
||
assert(pp.size() == segments + 1u);
|
||
assert(width.size() == segments*2);
|
||
}
|
||
|
||
// delete this line and insert new ones
|
||
lines.erase(lines.begin() + i);
|
||
for (size_t j = 0; j < segments; ++j) {
|
||
ThickLine new_line(pp[j], pp[j+1]);
|
||
new_line.a_width = width[2*j];
|
||
new_line.b_width = width[2*j+1];
|
||
lines.insert(lines.begin() + i + j, new_line);
|
||
}
|
||
|
||
-- i;
|
||
continue;
|
||
}
|
||
|
||
const double w = fmax(line.a_width, line.b_width);
|
||
if (path.polyline.points.empty()) {
|
||
path.polyline.append(line.a);
|
||
path.polyline.append(line.b);
|
||
// Convert from spacing to extrusion width based on the extrusion model
|
||
// of a square extrusion ended with semi circles.
|
||
flow.width = unscale<float>(w) + flow.height * float(1. - 0.25 * PI);
|
||
#ifdef SLIC3R_DEBUG
|
||
printf(" filling %f gap\n", flow.width);
|
||
#endif
|
||
path.mm3_per_mm = flow.mm3_per_mm();
|
||
path.width = flow.width;
|
||
path.height = flow.height;
|
||
} else {
|
||
thickness_delta = fabs(scale_(flow.width) - w);
|
||
if (thickness_delta <= tolerance) {
|
||
// the width difference between this line and the current flow width is
|
||
// within the accepted tolerance
|
||
path.polyline.append(line.b);
|
||
} else {
|
||
// we need to initialize a new line
|
||
paths.emplace_back(std::move(path));
|
||
path = ExtrusionPath(role);
|
||
-- i;
|
||
}
|
||
}
|
||
}
|
||
if (path.polyline.is_valid())
|
||
paths.emplace_back(std::move(path));
|
||
return paths;
|
||
}
|
||
|
||
static void variable_width(const ThickPolylines& polylines, ExtrusionRole role, Flow flow, std::vector<ExtrusionEntity*> &out)
|
||
{
|
||
// This value determines granularity of adaptive width, as G-code does not allow
|
||
// variable extrusion within a single move; this value shall only affect the amount
|
||
// of segments, and any pruning shall be performed before we apply this tolerance.
|
||
const float tolerance = float(scale_(0.05));
|
||
for (const ThickPolyline &p : polylines) {
|
||
ExtrusionPaths paths = thick_polyline_to_extrusion_paths(p, role, flow, tolerance);
|
||
// Append paths to collection.
|
||
if (! paths.empty()) {
|
||
if (paths.front().first_point() == paths.back().last_point())
|
||
out.emplace_back(new ExtrusionLoop(std::move(paths)));
|
||
else {
|
||
for (ExtrusionPath &path : paths)
|
||
out.emplace_back(new ExtrusionPath(std::move(path)));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Hierarchy of perimeters.
|
||
class PerimeterGeneratorLoop {
|
||
public:
|
||
// Polygon of this contour.
|
||
Polygon polygon;
|
||
// Is it a contour or a hole?
|
||
// Contours are CCW oriented, holes are CW oriented.
|
||
bool is_contour;
|
||
// Depth in the hierarchy. External perimeter has depth = 0. An external perimeter could be both a contour and a hole.
|
||
unsigned short depth;
|
||
// Children contour, may be both CCW and CW oriented (outer contours or holes).
|
||
std::vector<PerimeterGeneratorLoop> children;
|
||
|
||
PerimeterGeneratorLoop(Polygon polygon, unsigned short depth, bool is_contour) :
|
||
polygon(polygon), is_contour(is_contour), depth(depth) {}
|
||
// External perimeter. It may be CCW or CW oriented (outer contour or hole contour).
|
||
bool is_external() const { return this->depth == 0; }
|
||
// An island, which may have holes, but it does not have another internal island.
|
||
bool is_internal_contour() const;
|
||
};
|
||
|
||
typedef std::vector<PerimeterGeneratorLoop> PerimeterGeneratorLoops;
|
||
|
||
static ExtrusionEntityCollection traverse_loops(const PerimeterGenerator &perimeter_generator, const PerimeterGeneratorLoops &loops, ThickPolylines &thin_walls)
|
||
{
|
||
// loops is an arrayref of ::Loop objects
|
||
// turn each one into an ExtrusionLoop object
|
||
ExtrusionEntityCollection coll;
|
||
for (const PerimeterGeneratorLoop &loop : loops) {
|
||
bool is_external = loop.is_external();
|
||
|
||
ExtrusionRole role;
|
||
ExtrusionLoopRole loop_role;
|
||
role = is_external ? erExternalPerimeter : erPerimeter;
|
||
if (loop.is_internal_contour()) {
|
||
// Note that we set loop role to ContourInternalPerimeter
|
||
// also when loop is both internal and external (i.e.
|
||
// there's only one contour loop).
|
||
loop_role = elrContourInternalPerimeter;
|
||
} else {
|
||
loop_role = elrDefault;
|
||
}
|
||
|
||
// detect overhanging/bridging perimeters
|
||
ExtrusionPaths paths;
|
||
if (perimeter_generator.config->overhangs && perimeter_generator.layer_id > 0
|
||
&& !(perimeter_generator.object_config->support_material && perimeter_generator.object_config->support_material_contact_distance.value == 0)) {
|
||
// get non-overhang paths by intersecting this loop with the grown lower slices
|
||
extrusion_paths_append(
|
||
paths,
|
||
intersection_pl(loop.polygon, perimeter_generator.lower_slices_polygons()),
|
||
role,
|
||
is_external ? perimeter_generator.ext_mm3_per_mm() : perimeter_generator.mm3_per_mm(),
|
||
is_external ? perimeter_generator.ext_perimeter_flow.width : perimeter_generator.perimeter_flow.width,
|
||
(float)perimeter_generator.layer_height);
|
||
|
||
// get overhang paths by checking what parts of this loop fall
|
||
// outside the grown lower slices (thus where the distance between
|
||
// the loop centerline and original lower slices is >= half nozzle diameter
|
||
extrusion_paths_append(
|
||
paths,
|
||
diff_pl(loop.polygon, perimeter_generator.lower_slices_polygons()),
|
||
erOverhangPerimeter,
|
||
perimeter_generator.mm3_per_mm_overhang(),
|
||
perimeter_generator.overhang_flow.width,
|
||
perimeter_generator.overhang_flow.height);
|
||
|
||
// Reapply the nearest point search for starting point.
|
||
// We allow polyline reversal because Clipper may have randomly reversed polylines during clipping.
|
||
chain_and_reorder_extrusion_paths(paths, &paths.front().first_point());
|
||
} else {
|
||
ExtrusionPath path(role);
|
||
path.polyline = loop.polygon.split_at_first_point();
|
||
path.mm3_per_mm = is_external ? perimeter_generator.ext_mm3_per_mm() : perimeter_generator.mm3_per_mm();
|
||
path.width = is_external ? perimeter_generator.ext_perimeter_flow.width : perimeter_generator.perimeter_flow.width;
|
||
path.height = (float)perimeter_generator.layer_height;
|
||
paths.push_back(path);
|
||
}
|
||
|
||
coll.append(ExtrusionLoop(std::move(paths), loop_role));
|
||
}
|
||
|
||
// Append thin walls to the nearest-neighbor search (only for first iteration)
|
||
if (! thin_walls.empty()) {
|
||
variable_width(thin_walls, erExternalPerimeter, perimeter_generator.ext_perimeter_flow, coll.entities);
|
||
thin_walls.clear();
|
||
}
|
||
|
||
// Traverse children and build the final collection.
|
||
Point zero_point(0, 0);
|
||
std::vector<std::pair<size_t, bool>> chain = chain_extrusion_entities(coll.entities, &zero_point);
|
||
ExtrusionEntityCollection out;
|
||
for (const std::pair<size_t, bool> &idx : chain) {
|
||
assert(coll.entities[idx.first] != nullptr);
|
||
if (idx.first >= loops.size()) {
|
||
// This is a thin wall.
|
||
out.entities.reserve(out.entities.size() + 1);
|
||
out.entities.emplace_back(coll.entities[idx.first]);
|
||
coll.entities[idx.first] = nullptr;
|
||
if (idx.second)
|
||
out.entities.back()->reverse();
|
||
} else {
|
||
const PerimeterGeneratorLoop &loop = loops[idx.first];
|
||
assert(thin_walls.empty());
|
||
ExtrusionEntityCollection children = traverse_loops(perimeter_generator, loop.children, thin_walls);
|
||
out.entities.reserve(out.entities.size() + children.entities.size() + 1);
|
||
ExtrusionLoop *eloop = static_cast<ExtrusionLoop*>(coll.entities[idx.first]);
|
||
coll.entities[idx.first] = nullptr;
|
||
if (loop.is_contour) {
|
||
eloop->make_counter_clockwise();
|
||
out.append(std::move(children.entities));
|
||
out.entities.emplace_back(eloop);
|
||
} else {
|
||
eloop->make_clockwise();
|
||
out.entities.emplace_back(eloop);
|
||
out.append(std::move(children.entities));
|
||
}
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
void PerimeterGenerator::process()
|
||
{
|
||
// other perimeters
|
||
m_mm3_per_mm = this->perimeter_flow.mm3_per_mm();
|
||
coord_t perimeter_width = this->perimeter_flow.scaled_width();
|
||
coord_t perimeter_spacing = this->perimeter_flow.scaled_spacing();
|
||
|
||
// external perimeters
|
||
m_ext_mm3_per_mm = this->ext_perimeter_flow.mm3_per_mm();
|
||
coord_t ext_perimeter_width = this->ext_perimeter_flow.scaled_width();
|
||
coord_t ext_perimeter_spacing = this->ext_perimeter_flow.scaled_spacing();
|
||
coord_t ext_perimeter_spacing2 = this->ext_perimeter_flow.scaled_spacing(this->perimeter_flow);
|
||
|
||
// overhang perimeters
|
||
m_mm3_per_mm_overhang = this->overhang_flow.mm3_per_mm();
|
||
|
||
// solid infill
|
||
coord_t solid_infill_spacing = this->solid_infill_flow.scaled_spacing();
|
||
|
||
// Calculate the minimum required spacing between two adjacent traces.
|
||
// This should be equal to the nominal flow spacing but we experiment
|
||
// with some tolerance in order to avoid triggering medial axis when
|
||
// some squishing might work. Loops are still spaced by the entire
|
||
// flow spacing; this only applies to collapsing parts.
|
||
// For ext_min_spacing we use the ext_perimeter_spacing calculated for two adjacent
|
||
// external loops (which is the correct way) instead of using ext_perimeter_spacing2
|
||
// which is the spacing between external and internal, which is not correct
|
||
// and would make the collapsing (thus the details resolution) dependent on
|
||
// internal flow which is unrelated.
|
||
coord_t min_spacing = coord_t(perimeter_spacing * (1 - INSET_OVERLAP_TOLERANCE));
|
||
coord_t ext_min_spacing = coord_t(ext_perimeter_spacing * (1 - INSET_OVERLAP_TOLERANCE));
|
||
bool has_gap_fill = this->config->gap_fill_speed.value > 0;
|
||
|
||
// prepare grown lower layer slices for overhang detection
|
||
if (this->lower_slices != NULL && this->config->overhangs) {
|
||
// We consider overhang any part where the entire nozzle diameter is not supported by the
|
||
// lower layer, so we take lower slices and offset them by half the nozzle diameter used
|
||
// in the current layer
|
||
double nozzle_diameter = this->print_config->nozzle_diameter.get_at(this->config->perimeter_extruder-1);
|
||
m_lower_slices_polygons = offset(*this->lower_slices, float(scale_(+nozzle_diameter/2)));
|
||
}
|
||
|
||
// we need to process each island separately because we might have different
|
||
// extra perimeters for each one
|
||
for (const Surface &surface : this->slices->surfaces) {
|
||
// detect how many perimeters must be generated for this island
|
||
int loop_number = this->config->perimeters + surface.extra_perimeters - 1; // 0-indexed loops
|
||
ExPolygons last = union_ex(surface.expolygon.simplify_p(SCALED_RESOLUTION));
|
||
ExPolygons gaps;
|
||
if (loop_number >= 0) {
|
||
// In case no perimeters are to be generated, loop_number will equal to -1.
|
||
std::vector<PerimeterGeneratorLoops> contours(loop_number+1); // depth => loops
|
||
std::vector<PerimeterGeneratorLoops> holes(loop_number+1); // depth => loops
|
||
ThickPolylines thin_walls;
|
||
// we loop one time more than needed in order to find gaps after the last perimeter was applied
|
||
for (int i = 0;; ++ i) { // outer loop is 0
|
||
// Calculate next onion shell of perimeters.
|
||
ExPolygons offsets;
|
||
if (i == 0) {
|
||
// the minimum thickness of a single loop is:
|
||
// ext_width/2 + ext_spacing/2 + spacing/2 + width/2
|
||
offsets = this->config->thin_walls ?
|
||
offset2_ex(
|
||
last,
|
||
- float(ext_perimeter_width / 2. + ext_min_spacing / 2. - 1),
|
||
+ float(ext_min_spacing / 2. - 1)) :
|
||
offset_ex(last, - float(ext_perimeter_width / 2.));
|
||
// look for thin walls
|
||
if (this->config->thin_walls) {
|
||
// the following offset2 ensures almost nothing in @thin_walls is narrower than $min_width
|
||
// (actually, something larger than that still may exist due to mitering or other causes)
|
||
coord_t min_width = coord_t(scale_(this->ext_perimeter_flow.nozzle_diameter / 3));
|
||
ExPolygons expp = offset2_ex(
|
||
// medial axis requires non-overlapping geometry
|
||
diff_ex(to_polygons(last),
|
||
offset(offsets, float(ext_perimeter_width / 2.)),
|
||
true),
|
||
- float(min_width / 2.), float(min_width / 2.));
|
||
// the maximum thickness of our thin wall area is equal to the minimum thickness of a single loop
|
||
for (ExPolygon &ex : expp)
|
||
ex.medial_axis(ext_perimeter_width + ext_perimeter_spacing2, min_width, &thin_walls);
|
||
}
|
||
if (print_config->spiral_vase && offsets.size() > 1) {
|
||
// Remove all but the largest area polygon.
|
||
keep_largest_contour_only(offsets);
|
||
}
|
||
} else {
|
||
//FIXME Is this offset correct if the line width of the inner perimeters differs
|
||
// from the line width of the infill?
|
||
coord_t distance = (i == 1) ? ext_perimeter_spacing2 : perimeter_spacing;
|
||
offsets = this->config->thin_walls ?
|
||
// This path will ensure, that the perimeters do not overfill, as in
|
||
// prusa3d/Slic3r GH #32, but with the cost of rounding the perimeters
|
||
// excessively, creating gaps, which then need to be filled in by the not very
|
||
// reliable gap fill algorithm.
|
||
// Also the offset2(perimeter, -x, x) may sometimes lead to a perimeter, which is larger than
|
||
// the original.
|
||
offset2_ex(last,
|
||
- float(distance + min_spacing / 2. - 1.),
|
||
float(min_spacing / 2. - 1.)) :
|
||
// If "detect thin walls" is not enabled, this paths will be entered, which
|
||
// leads to overflows, as in prusa3d/Slic3r GH #32
|
||
offset_ex(last, - float(distance));
|
||
// look for gaps
|
||
if (has_gap_fill)
|
||
// not using safety offset here would "detect" very narrow gaps
|
||
// (but still long enough to escape the area threshold) that gap fill
|
||
// won't be able to fill but we'd still remove from infill area
|
||
append(gaps, diff_ex(
|
||
offset(last, - float(0.5 * distance)),
|
||
offset(offsets, float(0.5 * distance + 10)))); // safety offset
|
||
}
|
||
if (offsets.empty()) {
|
||
// Store the number of loops actually generated.
|
||
loop_number = i - 1;
|
||
// No region left to be filled in.
|
||
last.clear();
|
||
break;
|
||
} else if (i > loop_number) {
|
||
// If i > loop_number, we were looking just for gaps.
|
||
break;
|
||
}
|
||
for (const ExPolygon &expolygon : offsets) {
|
||
// Outer contour may overlap with an inner contour,
|
||
// inner contour may overlap with another inner contour,
|
||
// outer contour may overlap with itself.
|
||
//FIXME evaluate the overlaps, annotate each point with an overlap depth,
|
||
// compensate for the depth of intersection.
|
||
contours[i].emplace_back(PerimeterGeneratorLoop(expolygon.contour, i, true));
|
||
if (! expolygon.holes.empty()) {
|
||
holes[i].reserve(holes[i].size() + expolygon.holes.size());
|
||
for (const Polygon &hole : expolygon.holes)
|
||
holes[i].emplace_back(PerimeterGeneratorLoop(hole, i, false));
|
||
}
|
||
}
|
||
last = std::move(offsets);
|
||
if (i == loop_number && (! has_gap_fill || this->config->fill_density.value == 0)) {
|
||
// The last run of this loop is executed to collect gaps for gap fill.
|
||
// As the gap fill is either disabled or not
|
||
break;
|
||
}
|
||
}
|
||
|
||
// nest loops: holes first
|
||
for (int d = 0; d <= loop_number; ++ d) {
|
||
PerimeterGeneratorLoops &holes_d = holes[d];
|
||
// loop through all holes having depth == d
|
||
for (int i = 0; i < (int)holes_d.size(); ++ i) {
|
||
const PerimeterGeneratorLoop &loop = holes_d[i];
|
||
// find the hole loop that contains this one, if any
|
||
for (int t = d + 1; t <= loop_number; ++ t) {
|
||
for (int j = 0; j < (int)holes[t].size(); ++ j) {
|
||
PerimeterGeneratorLoop &candidate_parent = holes[t][j];
|
||
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
|
||
candidate_parent.children.push_back(loop);
|
||
holes_d.erase(holes_d.begin() + i);
|
||
-- i;
|
||
goto NEXT_LOOP;
|
||
}
|
||
}
|
||
}
|
||
// if no hole contains this hole, find the contour loop that contains it
|
||
for (int t = loop_number; t >= 0; -- t) {
|
||
for (int j = 0; j < (int)contours[t].size(); ++ j) {
|
||
PerimeterGeneratorLoop &candidate_parent = contours[t][j];
|
||
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
|
||
candidate_parent.children.push_back(loop);
|
||
holes_d.erase(holes_d.begin() + i);
|
||
-- i;
|
||
goto NEXT_LOOP;
|
||
}
|
||
}
|
||
}
|
||
NEXT_LOOP: ;
|
||
}
|
||
}
|
||
// nest contour loops
|
||
for (int d = loop_number; d >= 1; -- d) {
|
||
PerimeterGeneratorLoops &contours_d = contours[d];
|
||
// loop through all contours having depth == d
|
||
for (int i = 0; i < (int)contours_d.size(); ++ i) {
|
||
const PerimeterGeneratorLoop &loop = contours_d[i];
|
||
// find the contour loop that contains it
|
||
for (int t = d - 1; t >= 0; -- t) {
|
||
for (size_t j = 0; j < contours[t].size(); ++ j) {
|
||
PerimeterGeneratorLoop &candidate_parent = contours[t][j];
|
||
if (candidate_parent.polygon.contains(loop.polygon.first_point())) {
|
||
candidate_parent.children.push_back(loop);
|
||
contours_d.erase(contours_d.begin() + i);
|
||
-- i;
|
||
goto NEXT_CONTOUR;
|
||
}
|
||
}
|
||
}
|
||
NEXT_CONTOUR: ;
|
||
}
|
||
}
|
||
// at this point, all loops should be in contours[0]
|
||
ExtrusionEntityCollection entities = traverse_loops(*this, contours.front(), thin_walls);
|
||
// if brim will be printed, reverse the order of perimeters so that
|
||
// we continue inwards after having finished the brim
|
||
// TODO: add test for perimeter order
|
||
if (this->config->external_perimeters_first ||
|
||
(this->layer_id == 0 && this->print_config->brim_width.value > 0))
|
||
entities.reverse();
|
||
// append perimeters for this slice as a collection
|
||
if (! entities.empty())
|
||
this->loops->append(entities);
|
||
} // for each loop of an island
|
||
|
||
// fill gaps
|
||
if (! gaps.empty()) {
|
||
// collapse
|
||
double min = 0.2 * perimeter_width * (1 - INSET_OVERLAP_TOLERANCE);
|
||
double max = 2. * perimeter_spacing;
|
||
ExPolygons gaps_ex = diff_ex(
|
||
//FIXME offset2 would be enough and cheaper.
|
||
offset2_ex(gaps, - float(min / 2.), float(min / 2.)),
|
||
offset2_ex(gaps, - float(max / 2.), float(max / 2.)),
|
||
true);
|
||
ThickPolylines polylines;
|
||
for (const ExPolygon &ex : gaps_ex)
|
||
ex.medial_axis(max, min, &polylines);
|
||
if (! polylines.empty()) {
|
||
ExtrusionEntityCollection gap_fill;
|
||
variable_width(polylines, erGapFill, this->solid_infill_flow, gap_fill.entities);
|
||
/* Make sure we don't infill narrow parts that are already gap-filled
|
||
(we only consider this surface's gaps to reduce the diff() complexity).
|
||
Growing actual extrusions ensures that gaps not filled by medial axis
|
||
are not subtracted from fill surfaces (they might be too short gaps
|
||
that medial axis skips but infill might join with other infill regions
|
||
and use zigzag). */
|
||
//FIXME Vojtech: This grows by a rounded extrusion width, not by line spacing,
|
||
// therefore it may cover the area, but no the volume.
|
||
last = diff_ex(to_polygons(last), gap_fill.polygons_covered_by_width(10.f));
|
||
this->gap_fill->append(std::move(gap_fill.entities));
|
||
}
|
||
}
|
||
|
||
// create one more offset to be used as boundary for fill
|
||
// we offset by half the perimeter spacing (to get to the actual infill boundary)
|
||
// and then we offset back and forth by half the infill spacing to only consider the
|
||
// non-collapsing regions
|
||
coord_t inset =
|
||
(loop_number < 0) ? 0 :
|
||
(loop_number == 0) ?
|
||
// one loop
|
||
ext_perimeter_spacing / 2 :
|
||
// two or more loops?
|
||
perimeter_spacing / 2;
|
||
// only apply infill overlap if we actually have one perimeter
|
||
if (inset > 0)
|
||
inset -= coord_t(scale_(this->config->get_abs_value("infill_overlap", unscale<double>(inset + solid_infill_spacing / 2))));
|
||
// simplify infill contours according to resolution
|
||
Polygons pp;
|
||
for (ExPolygon &ex : last)
|
||
ex.simplify_p(SCALED_RESOLUTION, &pp);
|
||
// collapse too narrow infill areas
|
||
coord_t min_perimeter_infill_spacing = coord_t(solid_infill_spacing * (1. - INSET_OVERLAP_TOLERANCE));
|
||
// append infill areas to fill_surfaces
|
||
this->fill_surfaces->append(
|
||
offset2_ex(
|
||
union_ex(pp),
|
||
float(- inset - min_perimeter_infill_spacing / 2.),
|
||
float(min_perimeter_infill_spacing / 2.)),
|
||
stInternal);
|
||
} // for each island
|
||
}
|
||
|
||
bool PerimeterGeneratorLoop::is_internal_contour() const
|
||
{
|
||
// An internal contour is a contour containing no other contours
|
||
if (! this->is_contour)
|
||
return false;
|
||
for (const PerimeterGeneratorLoop &loop : this->children)
|
||
if (loop.is_contour)
|
||
return false;
|
||
return true;
|
||
}
|
||
|
||
}
|