From 60442badc2e565c04ed13daba2f9f01c9e7d1766 Mon Sep 17 00:00:00 2001 From: supermerill Date: Mon, 10 Dec 2018 17:42:29 +0100 Subject: [PATCH] concentric infill : now with gapfill --- xs/src/libslic3r/ExtrusionEntity.hpp | 12 ++ xs/src/libslic3r/Fill/FillConcentric.cpp | 137 +++++++++++++++-------- xs/src/libslic3r/Fill/FillConcentric.hpp | 8 +- xs/src/libslic3r/MedialAxis.cpp | 101 +++++++++++++++++ xs/src/libslic3r/MedialAxis.hpp | 5 + xs/src/libslic3r/PerimeterGenerator.cpp | 109 +----------------- xs/src/libslic3r/PerimeterGenerator.hpp | 5 +- 7 files changed, 213 insertions(+), 164 deletions(-) diff --git a/xs/src/libslic3r/ExtrusionEntity.hpp b/xs/src/libslic3r/ExtrusionEntity.hpp index 7eefdcdb35a..d478ce6591b 100644 --- a/xs/src/libslic3r/ExtrusionEntity.hpp +++ b/xs/src/libslic3r/ExtrusionEntity.hpp @@ -303,6 +303,18 @@ inline void extrusion_entities_append_paths(ExtrusionEntitiesPtr &dst, Polylines polylines.clear(); } +inline void extrusion_entities_append_loops(ExtrusionEntitiesPtr &dst, Polygons &loops, ExtrusionRole role, double mm3_per_mm, float width, float height) { + dst.reserve(dst.size() + loops.size()); + for (Polygon &poly : loops) { + if (poly.is_valid()) { + ExtrusionPath path(role, mm3_per_mm, width, height); + path.polyline.points = poly.points; + path.polyline.points.push_back(path.polyline.points.front()); + dst.emplace_back(new ExtrusionLoop(std::move(path))); + } + } +} + inline void extrusion_entities_append_loops(ExtrusionEntitiesPtr &dst, Polygons &&loops, ExtrusionRole role, double mm3_per_mm, float width, float height) { dst.reserve(dst.size() + loops.size()); diff --git a/xs/src/libslic3r/Fill/FillConcentric.cpp b/xs/src/libslic3r/Fill/FillConcentric.cpp index b21ad2799ea..987e81ede1d 100644 --- a/xs/src/libslic3r/Fill/FillConcentric.cpp +++ b/xs/src/libslic3r/Fill/FillConcentric.cpp @@ -1,64 +1,105 @@ #include "../ClipperUtils.hpp" #include "../ExPolygon.hpp" #include "../Surface.hpp" +#include "../ExtrusionEntityCollection.hpp" +#include "../MedialAxis.hpp" #include "FillConcentric.hpp" namespace Slic3r { -void FillConcentric::_fill_surface_single( - const FillParams ¶ms, - unsigned int thickness_layers, - const std::pair &direction, - ExPolygon &expolygon, - Polylines &polylines_out) -{ - // no rotation is supported for this infill pattern - BoundingBox bounding_box = expolygon.contour.bounding_box(); - - coord_t min_spacing = scale_(this->spacing); - coord_t distance = coord_t(min_spacing / params.density); - - if (params.density > 0.9999f && !params.dont_adjust) { - distance = this->_adjust_solid_spacing(bounding_box.size().x, distance); - this->spacing = unscale(distance); - } +void FillConcentric::fill_surface_extrusion(const Surface *surface, const FillParams ¶ms, + const Flow &flow, const ExtrusionRole &role, ExtrusionEntitiesPtr &out) { - Polygons loops = (Polygons)expolygon; - Polygons last = loops; - while (! last.empty()) { - last = offset2(last, -(distance + min_spacing/2), +min_spacing/2); - loops.insert(loops.end(), last.begin(), last.end()); - } + // Perform offset. + Slic3r::ExPolygons expp = offset_ex(surface->expolygon, float(scale_(0 - 0.5 * this->spacing))); + // Create the infills for each of the regions. + Polylines polylines_out; + for (size_t i = 0; i < expp.size(); ++i) { + //_fill_surface_single( + //params, + //surface->thickness_layers, + //_infill_direction(surface), + //expp[i], + //polylines_out); + ExPolygon expolygon = expp[i]; - // generate paths from the outermost to the innermost, to avoid - // adhesion problems of the first central tiny loops - loops = union_pt_chained(loops, false); - - // split paths using a nearest neighbor search - size_t iPathFirst = polylines_out.size(); - Point last_pos(0, 0); - for (const Polygon &loop : loops) { - polylines_out.push_back(loop.split_at_index(last_pos.nearest_point_index(loop))); - last_pos = polylines_out.back().last_point(); - } + coordf_t init_spacing = this->spacing; + + // no rotation is supported for this infill pattern + BoundingBox bounding_box = expolygon.contour.bounding_box(); - // clip the paths to prevent the extruder from getting exactly on the first point of the loop - // Keep valid paths only. - size_t j = iPathFirst; - for (size_t i = iPathFirst; i < polylines_out.size(); ++ i) { - polylines_out[i].clip_end(this->loop_clipping); - if (polylines_out[i].is_valid()) { - if (j < i) - polylines_out[j] = std::move(polylines_out[i]); - ++ j; + coord_t min_spacing = scale_(this->spacing); + coord_t distance = coord_t(min_spacing / params.density); + + if (params.density > 0.9999f && !params.dont_adjust) { + distance = this->_adjust_solid_spacing(bounding_box.size().x, distance); + this->spacing = unscale(distance); + } + + ExPolygons gaps; + Polygons loops = (Polygons)expolygon; + Polygons last = loops; + while (!last.empty()) { + Polygons next_onion = offset2(last, -(distance + min_spacing / 2), +min_spacing / 2); + loops.insert(loops.end(), next_onion.begin(), next_onion.end()); + append(gaps, diff_ex( + offset(last, -0.5f * distance), + offset(next_onion, 0.5f * distance + 10))); // safety offset + last = next_onion; } + + // generate paths from the outermost to the innermost, to avoid + // adhesion problems of the first central tiny loops + //note: useless if we don't apply no_sort flag + //loops = union_pt_chained(loops, false); + + + //get the role + ExtrusionRole good_role = role; + if (good_role == erNone || good_role == erCustom) { + good_role = (flow.bridge ? erBridgeInfill : + (surface->is_solid() ? + ((surface->is_top()) ? erTopSolidInfill : erSolidInfill) : + erInternalInfill)); + } + + ExtrusionEntityCollection *coll_nosort = new ExtrusionEntityCollection(); + coll_nosort->no_sort = true; //can be sorted inside the pass + extrusion_entities_append_loops( + coll_nosort->entities, loops, + good_role, + flow.mm3_per_mm() * params.flow_mult, + flow.width * params.flow_mult, + flow.height); + + //add gapfills + if (!gaps.empty() && params.density >= 1) { + // collapse + double min = 0.2 * distance * (1 - INSET_OVERLAP_TOLERANCE); + double max = 2. * distance; + ExPolygons gaps_ex = diff_ex( + offset2_ex(gaps, -min / 2, +min / 2), + offset2_ex(gaps, -max / 2, +max / 2), + true); + ThickPolylines polylines; + for (const ExPolygon &ex : gaps_ex) { + //remove too small gaps that are too hard to fill. + //ie one that are smaller than an extrusion with width of min and a length of max. + if (ex.area() > min*max) { + ex.medial_axis(ex, max, min, &polylines, flow.height); + } + } + if (!polylines.empty()) { + ExtrusionEntityCollection gap_fill = thin_variable_width(polylines, erGapFill, flow); + coll_nosort->append(gap_fill.entities); + } + } + + if (!coll_nosort->entities.empty()) + out.push_back(coll_nosort); + else delete coll_nosort; } - if (j < polylines_out.size()) - polylines_out.erase(polylines_out.begin() + j, polylines_out.end()); - //TODO: return ExtrusionLoop objects to get better chained paths, - // otherwise the outermost loop starts at the closest point to (0, 0). - // We want the loops to be split inside the G-code generator to get optimum path planning. } } // namespace Slic3r diff --git a/xs/src/libslic3r/Fill/FillConcentric.hpp b/xs/src/libslic3r/Fill/FillConcentric.hpp index 1286858ea46..d4523e17651 100644 --- a/xs/src/libslic3r/Fill/FillConcentric.hpp +++ b/xs/src/libslic3r/Fill/FillConcentric.hpp @@ -12,12 +12,8 @@ class FillConcentric : public Fill protected: virtual Fill* clone() const { return new FillConcentric(*this); }; - virtual void _fill_surface_single( - const FillParams ¶ms, - unsigned int thickness_layers, - const std::pair &direction, - ExPolygon &expolygon, - Polylines &polylines_out); + virtual void fill_surface_extrusion(const Surface *surface, const FillParams ¶ms, + const Flow &flow, const ExtrusionRole &role, ExtrusionEntitiesPtr &out); virtual bool no_sort() const { return true; } }; diff --git a/xs/src/libslic3r/MedialAxis.cpp b/xs/src/libslic3r/MedialAxis.cpp index ac6e61fd621..64bd1bdf461 100644 --- a/xs/src/libslic3r/MedialAxis.cpp +++ b/xs/src/libslic3r/MedialAxis.cpp @@ -1502,4 +1502,105 @@ MedialAxis::build(ThickPolylines* polylines_out) } +ExtrusionEntityCollection thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow) { + // 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 double tolerance = scale_(0.05); + + int id_line = 0; + ExtrusionEntityCollection coll; + for (const ThickPolyline &p : polylines) { + id_line++; + ExtrusionPaths paths; + ExtrusionPath path(role); + ThickLines lines = p.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 short segments = ceil(thickness_delta / tolerance); + const coordf_t seg_len = line_len / segments; + Points pp; + std::vector width; + { + pp.push_back(line.a); + width.push_back(line.a_width); + for (size_t j = 1; j < segments; ++j) { + pp.push_back(line.point_at(j*seg_len)); + + 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 + 1); + 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(w) + flow.height * (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 / 2) { + // 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)); + // Append paths to collection. + if (!paths.empty()) { + if (paths.front().first_point().coincides_with(paths.back().last_point())) { + coll.append(ExtrusionLoop(paths)); + } else { + //not a loop : avoid to "sort" it. + ExtrusionEntityCollection unsortable_coll(paths); + unsortable_coll.no_sort = true; + coll.append(unsortable_coll); + } + } + } + + return coll; +} + } // namespace Slic3r diff --git a/xs/src/libslic3r/MedialAxis.hpp b/xs/src/libslic3r/MedialAxis.hpp index 560e2bf0342..e4fd8e85d18 100644 --- a/xs/src/libslic3r/MedialAxis.hpp +++ b/xs/src/libslic3r/MedialAxis.hpp @@ -5,6 +5,8 @@ #include "ExPolygon.hpp" #include "Polyline.hpp" #include "Geometry.hpp" +#include "ExtrusionEntityCollection.hpp" +#include "Flow.hpp" #include #include "boost/polygon/voronoi.hpp" @@ -58,6 +60,9 @@ namespace Slic3r { void remove_too_short_polylines(ThickPolylines& pp, const coord_t min_size); void ensure_not_overextrude(ThickPolylines& pp); }; + + ExtrusionEntityCollection thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow); + } diff --git a/xs/src/libslic3r/PerimeterGenerator.cpp b/xs/src/libslic3r/PerimeterGenerator.cpp index 063e2981e82..066b6ceb7d7 100644 --- a/xs/src/libslic3r/PerimeterGenerator.cpp +++ b/xs/src/libslic3r/PerimeterGenerator.cpp @@ -448,7 +448,7 @@ void PerimeterGenerator::process() // append thin walls if (!thin_walls.empty()) { - ExtrusionEntityCollection tw = this->_variable_width + ExtrusionEntityCollection tw = thin_variable_width (thin_walls, erExternalPerimeter, this->ext_perimeter_flow); entities.append(tw.entities); @@ -488,7 +488,7 @@ void PerimeterGenerator::process() } } if (!polylines.empty()) { - ExtrusionEntityCollection gap_fill = this->_variable_width(polylines, + ExtrusionEntityCollection gap_fill = thin_variable_width(polylines, erGapFill, this->solid_infill_flow); this->gap_fill->append(gap_fill.entities); /* Make sure we don't infill narrow parts that are already gap-filled @@ -608,7 +608,7 @@ ExtrusionEntityCollection PerimeterGenerator::_traverse_loops( // append thin walls to the nearest-neighbor search (only for first iteration) if (!thin_walls.empty()) { - ExtrusionEntityCollection tw = this->_variable_width + ExtrusionEntityCollection tw = thin_variable_width (thin_walls, erExternalPerimeter, this->ext_perimeter_flow); coll.append(tw.entities); @@ -1222,109 +1222,6 @@ PerimeterGenerator::_traverse_and_join_loops(const PerimeterGeneratorLoop &loop, return my_loop; } - -ExtrusionEntityCollection PerimeterGenerator::_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow) const -{ - // 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 double tolerance = scale_(0.05); - - int id_line = 0; - ExtrusionEntityCollection coll; - for (const ThickPolyline &p : polylines) { - id_line++; - ExtrusionPaths paths; - ExtrusionPath path(role); - ThickLines lines = p.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 short segments = ceil(thickness_delta / tolerance); - const coordf_t seg_len = line_len / segments; - Points pp; - std::vector width; - { - pp.push_back(line.a); - width.push_back(line.a_width); - for (size_t j = 1; j < segments; ++j) { - pp.push_back(line.point_at(j*seg_len)); - - 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 + 1); - 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(w) + flow.height * (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/2) { - // 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)); - // Append paths to collection. - if (!paths.empty()) { - if (paths.front().first_point().coincides_with(paths.back().last_point())) { - coll.append(ExtrusionLoop(paths)); - } else { - //not a loop : avoid to "sort" it. - ExtrusionEntityCollection unsortable_coll(paths); - unsortable_coll.no_sort = true; - coll.append(unsortable_coll); - } - } - } - - return coll; -} - bool PerimeterGeneratorLoop::is_internal_contour() const { // An internal contour is a contour containing no other contours diff --git a/xs/src/libslic3r/PerimeterGenerator.hpp b/xs/src/libslic3r/PerimeterGenerator.hpp index 0aae5bdb10f..ecb6aa2ba59 100644 --- a/xs/src/libslic3r/PerimeterGenerator.hpp +++ b/xs/src/libslic3r/PerimeterGenerator.hpp @@ -99,13 +99,10 @@ class PerimeterGenerator { double _mm3_per_mm_overhang; Polygons _lower_slices_p; - ExtrusionEntityCollection _traverse_loops(const PerimeterGeneratorLoops &loops, - ThickPolylines &thin_walls) const; + ExtrusionEntityCollection _traverse_loops(const PerimeterGeneratorLoops &loops, ThickPolylines &thin_walls) const; ExtrusionLoop _traverse_and_join_loops(const PerimeterGeneratorLoop &loop, const PerimeterGeneratorLoops &childs, const Point entryPoint) const; ExtrusionLoop _extrude_and_cut_loop(const PerimeterGeneratorLoop &loop, const Point entryPoint, const Line &direction = Line(Point(0,0),Point(0,0))) const; PerimeterIntersectionPoint _get_nearest_point(const PerimeterGeneratorLoops &children, ExtrusionLoop &myPolylines, const coord_t dist_cut, const coord_t max_dist) const; - ExtrusionEntityCollection _variable_width - (const ThickPolylines &polylines, ExtrusionRole role, Flow flow) const; }; }