Fix too detailed gapfill

 * add resolution_internal to control it (and gyroid)
 * disallow gapfill lines to be split

19 files changed, 188 insertions, 99 deletions

diff --git a/src/libslic3r/ClipperUtils.cpp b/src/libslic3r/ClipperUtils.cpp
index 431c4ed0f..078c2d3f2 100644
--- a/src/libslic3r/ClipperUtils.cpp
+++ b/src/libslic3r/ClipperUtils.cpp
@@ -231,7 +231,7 @@ ClipperLib::Paths _offset(ClipperLib::Paths &&input, ClipperLib::EndType endType
         co.ArcTolerance = miterLimit;
     else
         co.MiterLimit = miterLimit;
-    double delta_scaled = delta * float(CLIPPER_OFFSET_SCALE);
+    double delta_scaled = delta * double(CLIPPER_OFFSET_SCALE);
     co.ShortestEdgeLength = double(std::abs(delta_scaled * CLIPPER_OFFSET_SHORTEST_EDGE_FACTOR));
     co.AddPaths(input, joinType, endType);
     ClipperLib::Paths retval;
diff --git a/src/libslic3r/ExtrusionEntity.cpp b/src/libslic3r/ExtrusionEntity.cpp
index 6b0611cca..5ed878499 100644
--- a/src/libslic3r/ExtrusionEntity.cpp
+++ b/src/libslic3r/ExtrusionEntity.cpp
@@ -376,7 +376,7 @@ void ExtrusionPrinter::use(const ExtrusionEntityCollection &collection) {
         if (i != 0) ss << ",";
         collection.entities[i]->visit(*this);
     }
-    if(collection.no_sort) ss<<", no_sort=true";
+    if(!collection.can_sort()) ss<<", no_sort=true";
     ss << "}";
 }
 
diff --git a/src/libslic3r/ExtrusionEntityCollection.cpp b/src/libslic3r/ExtrusionEntityCollection.cpp
index c31b06966..1dd41f67f 100644
--- a/src/libslic3r/ExtrusionEntityCollection.cpp
+++ b/src/libslic3r/ExtrusionEntityCollection.cpp
@@ -61,7 +61,7 @@ void ExtrusionEntityCollection::reverse()
     {
         // Don't reverse it if it's a loop, as it doesn't change anything in terms of elements ordering
         // and caller might rely on winding order
-        if (!ptr->can_reverse())
+        if (ptr->can_reverse() && !ptr->is_loop())
             ptr->reverse();
     }
     std::reverse(this->entities.begin(), this->entities.end());
@@ -151,7 +151,7 @@ ExtrusionEntityCollection ExtrusionEntityCollection::flatten(bool preserve_order
 }
 void
 FlatenEntities::use(const ExtrusionEntityCollection &coll) {
-    if ((coll.no_sort || this->to_fill.no_sort) && preserve_ordering) {
+    if ((!coll.can_sort() || !this->to_fill.can_sort()) && preserve_ordering) {
         FlatenEntities unsortable(coll, preserve_ordering);
         for (const ExtrusionEntity* entity : coll.entities) {
             entity->visit(unsortable);
diff --git a/src/libslic3r/ExtrusionEntityCollection.hpp b/src/libslic3r/ExtrusionEntityCollection.hpp
index 08d2fddba..3e625eeeb 100644
--- a/src/libslic3r/ExtrusionEntityCollection.hpp
+++ b/src/libslic3r/ExtrusionEntityCollection.hpp
@@ -24,6 +24,11 @@ inline ExtrusionEntitiesPtr filter_by_extrusion_role(const ExtrusionEntitiesPtr
 
 class ExtrusionEntityCollection : public ExtrusionEntity
 {
+private:
+    // set to tru to forbit to reorder and reverse all entities indie us.
+    bool no_sort;
+    // even if no_sort, allow to reverse() us (and our entities if they allow it, but they should) 
+    bool no_reverse;
 public:
     virtual ExtrusionEntityCollection* clone() const override { return new ExtrusionEntityCollection(*this); }
     // Create a new object, initialize it with this object using the move semantics.
@@ -33,14 +38,13 @@ public:
     /// Owned ExtrusionEntities and descendent ExtrusionEntityCollections.
     /// Iterating over this needs to check each child to see if it, too is a collection.
     ExtrusionEntitiesPtr entities;     // we own these entities
-    bool no_sort;
-    ExtrusionEntityCollection(): no_sort(false) {}
-    ExtrusionEntityCollection(const ExtrusionEntityCollection &other) : no_sort(other.no_sort) { this->append(other.entities); }
-    ExtrusionEntityCollection(ExtrusionEntityCollection &&other) : entities(std::move(other.entities)), no_sort(other.no_sort) {}
+    ExtrusionEntityCollection(): no_sort(false), no_reverse(false) {}
+    ExtrusionEntityCollection(const ExtrusionEntityCollection &other) : no_sort(other.no_sort), no_reverse(other.no_reverse) { this->append(other.entities); }
+    ExtrusionEntityCollection(ExtrusionEntityCollection &&other) : entities(std::move(other.entities)), no_sort(other.no_sort), no_reverse(other.no_reverse) {}
     explicit ExtrusionEntityCollection(const ExtrusionPaths &paths);
     ExtrusionEntityCollection& operator=(const ExtrusionEntityCollection &other);
     ExtrusionEntityCollection& operator=(ExtrusionEntityCollection &&other)
-        { this->entities = std::move(other.entities); this->no_sort = other.no_sort; return *this; }
+        { this->entities = std::move(other.entities); this->no_sort = other.no_sort; this->no_reverse = other.no_reverse; return *this; }
     ~ExtrusionEntityCollection() { clear(); }
 
     /// Operator to convert and flatten this collection to a single vector of ExtrusionPaths.
@@ -55,7 +59,9 @@ public:
         }
         return out;
     }
-    bool can_reverse() const override { return !this->no_sort; }
+    void set_can_sort_reverse(bool sort, bool reverse) { this->no_sort = !sort; this->no_reverse = !reverse; }
+    bool can_sort() const { return !this->no_sort; }
+    bool can_reverse() const override { return can_sort() || !this->no_reverse; }
     bool empty() const { return this->entities.empty(); }
     void clear();
     void swap (ExtrusionEntityCollection &c);
@@ -152,7 +158,7 @@ class FlatenEntities : public ExtrusionVisitorConst {
 public:
     FlatenEntities(bool preserve_ordering) : preserve_ordering(preserve_ordering) {}
     FlatenEntities(ExtrusionEntityCollection pattern, bool preserve_ordering) : preserve_ordering(preserve_ordering) {
-        to_fill.no_sort = pattern.no_sort;
+        to_fill.set_can_sort_reverse(pattern.can_sort(), pattern.can_reverse());
     }
     ExtrusionEntityCollection get() {
         return to_fill;
diff --git a/src/libslic3r/Fill/Fill.cpp b/src/libslic3r/Fill/Fill.cpp
index d09a9b9b6..93360eb75 100644
--- a/src/libslic3r/Fill/Fill.cpp
+++ b/src/libslic3r/Fill/Fill.cpp
@@ -413,9 +413,9 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
             m_regions[region_id]->fills.append(fills_by_priority[0]->entities);
             delete fills_by_priority[0];
         } else {
-            m_regions[region_id]->fills.no_sort = true;
+            m_regions[region_id]->fills.set_can_sort_reverse(false, false);
             ExtrusionEntityCollection* eec = new ExtrusionEntityCollection();
-            eec->no_sort = true;
+            eec->set_can_sort_reverse(false, false);
             m_regions[region_id]->fills.entities.push_back(eec);
             for (ExtrusionEntityCollection* per_priority : fills_by_priority) {
                 if (!per_priority->entities.empty())
@@ -580,9 +580,9 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
     for (LayerRegion *layerm : m_regions)
         for (const ExtrusionEntity *thin_fill : layerm->thin_fills.entities) {
             ExtrusionEntityCollection *collection = new ExtrusionEntityCollection();
-            if (layerm->fills.no_sort && layerm->fills.entities.size() > 0 && layerm->fills.entities[0]->is_collection()) {
+            if (!layerm->fills.can_sort() && layerm->fills.entities.size() > 0 && layerm->fills.entities[0]->is_collection()) {
                 ExtrusionEntityCollection* no_sort_fill = static_cast<ExtrusionEntityCollection*>(layerm->fills.entities[0]);
-                if (no_sort_fill->no_sort && no_sort_fill->entities.size() > 0 && no_sort_fill->entities[0]->is_collection())
+                if (!no_sort_fill->can_sort() && no_sort_fill->entities.size() > 0 && no_sort_fill->entities[0]->is_collection())
                     static_cast<ExtrusionEntityCollection*>(no_sort_fill->entities[0])->entities.push_back(collection);
             } else
                 layerm->fills.entities.push_back(collection);
@@ -593,7 +593,7 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
     for (LayerRegion *layerm : m_regions)
         for (size_t i1 = 0; i1 < layerm->fills.entities.size(); ++i1) {
             assert(dynamic_cast<ExtrusionEntityCollection*>(layerm->fills.entities[i1]) != nullptr);
-            if (layerm->fills.no_sort && layerm->fills.entities.size() > 0 && i1 == 0){
+            if (!layerm->fills.can_sort() && layerm->fills.entities.size() > 0 && i1 == 0){
                 ExtrusionEntityCollection* no_sort_fill = static_cast<ExtrusionEntityCollection*>(layerm->fills.entities[0]);
                 assert(no_sort_fill != nullptr);
                 assert(!no_sort_fill->empty());
@@ -601,7 +601,7 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
                     ExtrusionEntityCollection* priority_fill = dynamic_cast<ExtrusionEntityCollection*>(no_sort_fill->entities[i2]);
                     assert(priority_fill != nullptr);
                     assert(!priority_fill->empty());
-                    if (no_sort_fill->no_sort) {
+                    if (!no_sort_fill->can_sort()) {
                         for (size_t i3 = 0; i3 < priority_fill->entities.size(); ++i3)
                             assert(dynamic_cast<ExtrusionEntityCollection*>(priority_fill->entities[i3]) != nullptr);
                     }
@@ -780,7 +780,7 @@ void Layer::make_ironing()
                 ExtrusionEntityCollection *eec = new ExtrusionEntityCollection();
                 ironing_params.layerm->ironings.entities.push_back(eec);
                 // Don't sort the ironing infill lines as they are monotonicly ordered.
-                eec->no_sort = true;
+                eec->set_can_sort_reverse(false, false);
                 extrusion_entities_append_paths(
                     eec->entities, std::move(polylines),
                     erIroning,
diff --git a/src/libslic3r/Fill/FillBase.cpp b/src/libslic3r/Fill/FillBase.cpp
index 26b73bd25..1e6dff4aa 100644
--- a/src/libslic3r/Fill/FillBase.cpp
+++ b/src/libslic3r/Fill/FillBase.cpp
@@ -211,7 +211,7 @@ void Fill::fill_surface_extrusion(const Surface *surface, const FillParams &para
     // Save into layer.
     auto *eec = new ExtrusionEntityCollection();
     /// pass the no_sort attribute to the extrusion path
-    eec->no_sort = this->no_sort();
+    eec->set_can_sort_reverse(!this->no_sort(), !this->no_sort());
     /// add it into the collection
     out.push_back(eec);
     //get the role
@@ -269,7 +269,7 @@ Fill::do_gap_fill(const ExPolygons& gapfill_areas, const FillParams& params, Ext
         }
 #endif
 
-        ExtrusionEntityCollection gap_fill = thin_variable_width(polylines_gapfill, erGapFill, params.flow);
+        ExtrusionEntityCollection gap_fill = thin_variable_width(polylines_gapfill, erGapFill, params.flow, scale_t(params.config->get_computed_value("resolution_internal")));
         //set role if needed
         /*if (params.role != erSolidInfill) {
             ExtrusionSetRole set_good_role(params.role);
@@ -278,7 +278,7 @@ Fill::do_gap_fill(const ExPolygons& gapfill_areas, const FillParams& params, Ext
         //move them into the collection
         if (!gap_fill.entities.empty()) {
             ExtrusionEntityCollection* coll_gapfill = new ExtrusionEntityCollection();
-            coll_gapfill->no_sort = this->no_sort();
+            coll_gapfill->set_can_sort_reverse(!this->no_sort(), !this->no_sort());
             coll_gapfill->append(std::move(gap_fill.entities));
             coll_out.push_back(coll_gapfill);
         }
diff --git a/src/libslic3r/Fill/FillConcentric.cpp b/src/libslic3r/Fill/FillConcentric.cpp
index 6da55e454..c8616f42f 100644
--- a/src/libslic3r/Fill/FillConcentric.cpp
+++ b/src/libslic3r/Fill/FillConcentric.cpp
@@ -128,7 +128,7 @@ FillConcentricWGapFill::fill_surface_extrusion(
         ExtrusionRole good_role = getRoleFromSurfaceType(params, surface);
 
         ExtrusionEntityCollection *coll_nosort = new ExtrusionEntityCollection();
-        coll_nosort->no_sort = true; //can be sorted inside the pass
+        coll_nosort->set_can_sort_reverse(false, false); //can be sorted inside the pass
         extrusion_entities_append_loops(
             coll_nosort->entities, loops,
             good_role,
@@ -154,7 +154,7 @@ FillConcentricWGapFill::fill_surface_extrusion(
                 }
             }
             if (!polylines.empty() && !is_bridge(good_role)) {
-                ExtrusionEntityCollection gap_fill = thin_variable_width(polylines, erGapFill, params.flow);
+                ExtrusionEntityCollection gap_fill = thin_variable_width(polylines, erGapFill, params.flow, scale_t(params.config->get_computed_value("resolution_internal")));
                 //set role if needed
                 if (good_role != erSolidInfill) {
                     ExtrusionSetRole set_good_role(good_role);
diff --git a/src/libslic3r/Fill/FillGyroid.cpp b/src/libslic3r/Fill/FillGyroid.cpp
index c51cdf914..0ff0972c5 100644
--- a/src/libslic3r/Fill/FillGyroid.cpp
+++ b/src/libslic3r/Fill/FillGyroid.cpp
@@ -101,13 +101,8 @@ static std::vector<Vec2d> make_one_period(double width, double scaleFactor, doub
     return points;
 }
 
-static Polylines make_gyroid_waves(double gridZ, double density_adjusted, double line_spacing, double width, double height)
+static Polylines make_gyroid_waves(coordf_t gridZ, coordf_t scaleFactor, double width, double height, double tolerance)
 {
-    const double scaleFactor = scale_(line_spacing) / density_adjusted;
-
-    // tolerance in scaled units. clamp the maximum tolerance as there's
-    // no processing-speed benefit to do so beyond a certain point
-    const double tolerance = std::min(line_spacing / 2, FillGyroid::PatternTolerance) / unscale<double>(scaleFactor);
 
     //scale factor for 5% : 8 712 388
     // 1z = 10^-6 mm ?
@@ -167,13 +162,22 @@ void FillGyroid::_fill_surface_single(
     // align bounding box to a multiple of our grid module
     bb.merge(_align_to_grid(bb.min, Point(2*M_PI*distance, 2*M_PI*distance)));
 
+    // tolerance in scaled units. clamp the maximum tolerance as there's
+    // no processing-speed benefit to do so beyond a certain point
+    const coordf_t scaleFactor = scale_d(this->get_spacing()) / density_adjusted;
+    const double tolerance_old = std::min(this->get_spacing() / 2, FillGyroid::PatternTolerance) / unscaled(scaleFactor);
+    const double tolerance_old2 = std::min(this->get_spacing() / 2, FillGyroid::PatternTolerance) * density_adjusted  / this->get_spacing();
+    const double tolerance = params.config->get_computed_value("resolution_internal") * density_adjusted / this->get_spacing();
+    std::cout << "gyroid tolerance: " << tolerance_old << " == " << tolerance_old2 << " ? "<< tolerance << "\n";
+    std::cout << "this->get_spacing(): " << this->get_spacing() << " , scaleFactor= " << unscaled(scaleFactor) << " , min(spa, 0.2)= " << std::min(this->get_spacing() / 2, FillGyroid::PatternTolerance) << "\n";
+
     // generate pattern
     Polylines polylines = make_gyroid_waves(
-        (double)scale_(this->z),
-        density_adjusted,
-        this->get_spacing(),
+        scale_d(this->z),
+        scaleFactor,
         ceil(bb.size()(0) / distance) + 1.,
-        ceil(bb.size()(1) / distance) + 1.);
+        ceil(bb.size()(1) / distance) + 1.,
+        tolerance);
 
     // shift the polyline to the grid origin
     for (Polyline &pl : polylines)
diff --git a/src/libslic3r/Fill/FillRectilinear.cpp b/src/libslic3r/Fill/FillRectilinear.cpp
index 598ef50d1..6495dae72 100644
--- a/src/libslic3r/Fill/FillRectilinear.cpp
+++ b/src/libslic3r/Fill/FillRectilinear.cpp
@@ -3208,7 +3208,7 @@ FillRectilinearPeri::fill_surface_extrusion(const Surface *surface, const FillPa
 {
     ExtrusionEntityCollection *eecroot = new ExtrusionEntityCollection();
     //you don't want to sort the extrusions: big infill first, small second
-    eecroot->no_sort = true;
+    eecroot->set_can_sort_reverse(false, false);
 
     // === extrude perimeter ===
     Polylines polylines_1;
@@ -3231,7 +3231,7 @@ FillRectilinearPeri::fill_surface_extrusion(const Surface *surface, const FillPa
         // Save into layer.
         ExtrusionEntityCollection *eec = new ExtrusionEntityCollection();
         /// pass the no_sort attribute to the extrusion path
-        eec->no_sort = this->no_sort();
+        eec->set_can_sort_reverse(!this->no_sort(), !this->no_sort());
         /// add it into the collection
         eecroot->entities.push_back(eec);
         //get the role
@@ -3263,7 +3263,7 @@ FillRectilinearPeri::fill_surface_extrusion(const Surface *surface, const FillPa
         // Save into layer.
         ExtrusionEntityCollection *eec = new ExtrusionEntityCollection();
         /// pass the no_sort attribute to the extrusion path
-        eec->no_sort = this->no_sort();
+        eec->set_can_sort_reverse(!this->no_sort(), !this->no_sort());
         /// add it into the collection
         eecroot->entities.push_back(eec);
         //get the role
@@ -3365,7 +3365,7 @@ FillRectilinearSawtooth::fill_surface_extrusion(const Surface *surface, const Fi
     if (!polylines_out.empty()) {
         ExtrusionEntityCollection *eec = new ExtrusionEntityCollection();
         /// pass the no_sort attribute to the extrusion path
-        eec->no_sort = this->no_sort();
+        eec->set_can_sort_reverse(!this->no_sort(), !this->no_sort());
 
         ExtrusionRole good_role = getRoleFromSurfaceType(params, surface);
 
@@ -3489,7 +3489,7 @@ FillRectilinearWGapFill::split_polygon_gap_fill(const Surface &surface, const Fi
 void
 FillRectilinearWGapFill::fill_surface_extrusion(const Surface *surface, const FillParams &params, ExtrusionEntitiesPtr &out) const {
     ExtrusionEntityCollection *coll_nosort = new ExtrusionEntityCollection();
-    coll_nosort->no_sort = true; //can be sorted inside the pass
+    coll_nosort->set_can_sort_reverse(false, false); //can be sorted inside the pass but thew two pass need to be done one after the other
     ExtrusionRole good_role = getRoleFromSurfaceType(params, surface);
 
     //// remove areas for gapfill 
@@ -3558,9 +3558,9 @@ FillRectilinearWGapFill::fill_surface_extrusion(const Surface *surface, const Fi
         /// pass the no_sort attribute to the extrusion path
         //don't force monotonic if not top or bottom
         if (is_monotonic())
-            eec->no_sort = true;
+            eec->set_can_sort_reverse(false, false);
         else
-            eec->no_sort = this->no_sort();
+            eec->set_can_sort_reverse(!this->no_sort(), !this->no_sort());
 
         extrusion_entities_append_paths(
             eec->entities, polylines_rectilinear,
diff --git a/src/libslic3r/Fill/FillSmooth.cpp b/src/libslic3r/Fill/FillSmooth.cpp
index 444e61132..2c6f54da8 100644
--- a/src/libslic3r/Fill/FillSmooth.cpp
+++ b/src/libslic3r/Fill/FillSmooth.cpp
@@ -24,7 +24,7 @@ namespace Slic3r {
         
         // Save into layer smoothing path.
         ExtrusionEntityCollection *eec = new ExtrusionEntityCollection();
-        eec->no_sort = params.monotonic;
+        eec->set_can_sort_reverse(!params.monotonic, !params.monotonic);
         FillParams params_modifided = params;
         if (params.config != NULL && idx > 0) params_modifided.density /= (float)params.config->fill_smooth_width.get_abs_value(1);
         else if (params.config != NULL && idx == 0) params_modifided.density *= 1;
@@ -131,7 +131,7 @@ namespace Slic3r {
         //create root node
         ExtrusionEntityCollection *eecroot = new ExtrusionEntityCollection();
         //you don't want to sort the extrusions: big infill first, small second
-        eecroot->no_sort = true;
+        eecroot->set_can_sort_reverse(false, false);
 
         // first infill
         FillParams first_pass_params = params;
diff --git a/src/libslic3r/GCode.cpp b/src/libslic3r/GCode.cpp
index ee6eb01f0..edf1677b2 100644
--- a/src/libslic3r/GCode.cpp
+++ b/src/libslic3r/GCode.cpp
@@ -3455,7 +3455,7 @@ std::string GCode::extrude_entity(const ExtrusionEntity &entity, const std::stri
 }
 
 void GCode::use(const ExtrusionEntityCollection &collection) {
-    if (collection.no_sort || collection.role() == erMixed) {
+    if (!collection.can_sort() || collection.role() == erMixed) {
         for (const ExtrusionEntity* next_entity : collection.entities) {
             next_entity->visit(*this);
         }
diff --git a/src/libslic3r/Line.hpp b/src/libslic3r/Line.hpp
index d93e37e7f..88a9d4db2 100644
--- a/src/libslic3r/Line.hpp
+++ b/src/libslic3r/Line.hpp
@@ -97,7 +97,7 @@ public:
     ThickLine(const Point& a, const Point& b) : Line(a, b), a_width(0), b_width(0) {}
     ThickLine(const Point& a, const Point& b, double wa, double wb) : Line(a, b), a_width(wa), b_width(wb) {}
 
-    double a_width, b_width;
+    coordf_t a_width, b_width;
 };
 
 class Line3
diff --git a/src/libslic3r/MedialAxis.cpp b/src/libslic3r/MedialAxis.cpp
index 1ed1320f7..a84b69204 100644
--- a/src/libslic3r/MedialAxis.cpp
+++ b/src/libslic3r/MedialAxis.cpp
@@ -1923,82 +1923,115 @@ MedialAxis::build(ThickPolylines &polylines_out)
 }
 
 ExtrusionEntityCollection
-thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow)
+thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow, coord_t resolution_internal)
 {
+    assert(resolution_internal > SCALED_EPSILON);
+
     // 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 coord_t tolerance = 4 * SCALED_RESOLUTION;//scale_(0.05);
+    const coord_t tolerance = flow.scaled_width() / 10;//scale_(0.05);
     
     ExtrusionEntityCollection coll;
     for (const ThickPolyline &p : polylines) {
         ExtrusionPaths paths;
         ExtrusionPath path(role);
         ThickLines lines = p.thicklines();
-        
+
+        coordf_t saved_line_len = 0;
         for (int i = 0; i < (int)lines.size(); ++i) {
             ThickLine& line = lines[i];
-            
+
             const coordf_t line_len = line.length();
-            if (line_len < SCALED_EPSILON) continue;
-            
+            const coordf_t prev_line_len = saved_line_len;
+            saved_line_len = line_len;
+
             assert(line.a_width >= 0);
             assert(line.b_width >= 0);
             coord_t thickness_delta = std::abs(line.a_width - line.b_width);
-            if (thickness_delta > tolerance && ceil(float(thickness_delta) / float(tolerance)) > 2) {
-                const uint16_t segments = 1 + (uint16_t) std::min((uint32_t)16000, (uint32_t)ceil(float(thickness_delta) / float(tolerance)));
-                Points pp;
-                std::vector<coordf_t> width;
-                {
+
+            // split lines ?
+            if (resolution_internal < line_len) {
+                if (thickness_delta > tolerance && ceil(float(thickness_delta) / float(tolerance)) > 2) {
+                    const uint16_t segments = 1 + (uint16_t)std::min((uint32_t)16000, (uint32_t)ceil(float(thickness_delta) / float(tolerance)));
+                    Points pp;
+                    std::vector<coordf_t> width;
+                    {
+                        for (size_t j = 0; j < segments; ++j) {
+                            pp.push_back(line.a.interpolate(((double)j) / segments, line.b));
+                            double percent_width = ((double)j) / (segments - 1);
+                            width.push_back(line.a_width * (1 - percent_width) + line.b_width * percent_width);
+                        }
+                        pp.push_back(line.b);
+
+                        assert(pp.size() == segments + 1);
+                        assert(width.size() == segments);
+                    }
+
+                    // delete this line and insert new ones
+                    lines.erase(lines.begin() + i);
                     for (size_t j = 0; j < segments; ++j) {
-                        pp.push_back(line.a.interpolate(((double)j) / segments, line.b));
-                        double percent_width = ((double)j) / (segments-1);
-                        width.push_back(line.a_width * (1 - percent_width) + line.b_width * percent_width);
+                        ThickLine new_line(pp[j], pp[j + 1]);
+                        new_line.a_width = width[j];
+                        new_line.b_width = width[j];
+                        lines.insert(lines.begin() + i + j, new_line);
                     }
-                    pp.push_back(line.b);
 
-                    assert(pp.size() == segments + 1);
-                    assert(width.size() == segments);
+                    // go back to the start of this loop iteration
+                    --i;
+                    continue;
+                } else if (thickness_delta > 0) {
+                    //create a middle point
+                    ThickLine new_line(line.a.interpolate(0.5, line.b), line.b);
+                    new_line.a_width = line.b_width;
+                    new_line.b_width = line.b_width;
+                    line.b = new_line.a;
+                    line.b_width = line.a_width;
+                    lines.insert(lines.begin() + i + 1, new_line);
+
+                    // go back to the start of this loop iteration
+                    --i;
+                    continue;
                 }
-
-                // delete this line and insert new ones
+            } else if (i > 0 && resolution_internal > line_len + prev_line_len) {
+                ThickLine& prev_line = lines[i - 1];
+                //merge lines?
+                coordf_t width = prev_line_len * (prev_line.a_width + prev_line.b_width) / 2;
+                width += line_len * (line.a_width + line.b_width) / 2;
+                prev_line.b = line.b;
+                coordf_t new_length = prev_line.length();
+                width /= new_length;
+                prev_line.a_width = width;
+                prev_line.b_width = width;
+                saved_line_len = new_length;
+                //erase 'line'
                 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[j];
-                    new_line.b_width = width[j];
-                    lines.insert(lines.begin() + i + j, new_line);
-                }
-
                 --i;
                 continue;
             } else if (thickness_delta > 0) {
-                //create a middle point
-                ThickLine new_line(line.a.interpolate(0.5, line.b), line.b);
-                new_line.a_width = line.b_width;
-                new_line.b_width = line.b_width;
-                line.b = new_line.a;
+                //set width as a middle-ground
+                line.a_width = (line.a_width + line.b_width) / 2;
                 line.b_width = line.a_width;
-                lines.insert(lines.begin() + i + 1, new_line);
-
-                --i;
-                continue;
             }
+        }
+        for (int i = 0; i < (int)lines.size(); ++i) {
+            ThickLine& line = lines[i];
+
             //gapfill : we want to be able to fill the voids (touching the perimeters), so the spacing is what we want.
             //thinwall: we want the extrusion to not go out of the polygon, so the width is what we want.
             //  but we can't extrude with a negative spacing, so we have to gradually fall back to spacing if the width is too small.
 
             // default: extrude a thin wall that doesn't go outside of the specified width.
-            coordf_t wanted_width = unscale<coordf_t>(line.a_width);
+            double wanted_width = unscaled(line.a_width);
             if (role == erGapFill) {
                 // Convert from spacing to extrusion width based on the extrusion model
                 // of a square extrusion ended with semi circles.
-                wanted_width = unscale<coordf_t>(line.a_width) + flow.height * (1. - 0.25 * PI);
+                wanted_width = unscaled(line.a_width) + flow.height * (1. - 0.25 * PI);
             } else if (unscale<coordf_t>(line.a_width) < 2 * flow.height * (1. - 0.25 * PI)) {
                 //width (too) small, be sure to not extrude with negative spacing.
                 //we began to fall back to spacing gradually even before the spacing go into the negative
                 //  to make extrusion1 < extrusion2 if width1 < width2 even if width2 is too small. 
-                wanted_width = unscale<coordf_t>(line.a_width)*0.35 + 1.3 * flow.height * (1. - 0.25 * PI);
+                wanted_width = unscaled(line.a_width)*0.35 + 1.3 * flow.height * (1. - 0.25 * PI);
             }
 
             if (path.polyline.points.empty()) {
@@ -2012,7 +2045,7 @@ thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow fl
                 path.width = flow.width;
                 path.height = flow.height;
             } else {
-                thickness_delta = scale_(fabs(flow.width - wanted_width));
+                coord_t thickness_delta = scale_t(fabs(flow.width - wanted_width));
                 if (thickness_delta <= tolerance / 2) {
                     // the width difference between this line and the current flow width is 
                     // within the accepted tolerance
@@ -2021,12 +2054,21 @@ thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow fl
                     // we need to initialize a new line
                     paths.emplace_back(std::move(path));
                     path = ExtrusionPath(role);
-                    --i;
+                    flow.width = wanted_width;
+                    path.polyline.append(line.a);
+                    path.polyline.append(line.b);
+                    assert(flow.mm3_per_mm() == flow.mm3_per_mm());
+                    assert(flow.width == flow.width);
+                    assert(flow.height == flow.height);
+                    path.mm3_per_mm = flow.mm3_per_mm();
+                    path.width = flow.width;
+                    path.height = flow.height;
                 }
             }
         }
         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())) {
@@ -2034,11 +2076,21 @@ thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow fl
             } else {
                 if (role == erThinWall){
                     //thin walls : avoid to cut them, please.
+                    //also, keep the start, as the start should be already in a frontier where possible.
                     ExtrusionEntityCollection unsortable_coll(paths);
-                    unsortable_coll.no_sort = true;
+                    unsortable_coll.set_can_sort_reverse(false, false);
                     coll.append(unsortable_coll);
-                }else //gap fill : cut them as much as you want
-                    coll.append(paths);
+                } else {
+                    if (paths.size() <= 1) {
+                        coll.append(paths);
+                    } else {
+                        ExtrusionEntityCollection unsortable_coll(paths);
+                        //gap fill : can reverse, but refrain from cutting them as it creates a mess.
+                        // I say that, but currently (false, true) does bad things.
+                        unsortable_coll.set_can_sort_reverse(false, true);
+                        coll.append(unsortable_coll);
+                    }
+                }
             }
         }
     }
diff --git a/src/libslic3r/MedialAxis.hpp b/src/libslic3r/MedialAxis.hpp
index 69bd94268..18a7eb2f0 100644
--- a/src/libslic3r/MedialAxis.hpp
+++ b/src/libslic3r/MedialAxis.hpp
@@ -115,7 +115,7 @@ class MedialAxis {
 };
     
     /// create a ExtrusionEntityCollection from ThickPolylines, discretizing the variable width into little sections (of 4*SCALED_RESOLUTION length) where needed.
-    ExtrusionEntityCollection thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow);
+    ExtrusionEntityCollection thin_variable_width(const ThickPolylines &polylines, ExtrusionRole role, Flow flow, coord_t resolution_internal);
 }
 
 
diff --git a/src/libslic3r/PerimeterGenerator.cpp b/src/libslic3r/PerimeterGenerator.cpp
index 9f98eeff5..6ba0c0815 100644
--- a/src/libslic3r/PerimeterGenerator.cpp
+++ b/src/libslic3r/PerimeterGenerator.cpp
@@ -939,7 +939,7 @@ void PerimeterGenerator::process()
                 // append thin walls
                 if (!thin_walls.empty()) {
                     ExtrusionEntityCollection tw = thin_variable_width
-                    (thin_walls, erThinWall, this->ext_perimeter_flow);
+                    (thin_walls, erThinWall, this->ext_perimeter_flow, std::max(ext_perimeter_width/4, scale_t(this->print_config->resolution)));
 
                     entities.append(tw.entities);
                     thin_walls.clear();
@@ -1086,7 +1086,17 @@ void PerimeterGenerator::process()
             // create extrusion from lines
             if (!polylines.empty()) {
                 ExtrusionEntityCollection gap_fill = thin_variable_width(polylines,
-                    erGapFill, this->solid_infill_flow);
+                    erGapFill, this->solid_infill_flow, scale_t(this->print_config->resolution_internal));
+
+                //{
+                //    static int isaqsdsdfsdfqzfn = 0;
+                //    std::stringstream stri;
+                //    stri << this->layer->id() << "_gapfill_" << isaqsdsdfsdfqzfn++ << ".svg";
+                //    SVG svg(stri.str());
+                //    svg.draw((surface.expolygon), "grey");
+                //    svg.draw(polylines, "blue");
+                //    svg.Close();
+                //}
                 this->gap_fill->append(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).
@@ -1478,7 +1488,7 @@ ExtrusionEntityCollection PerimeterGenerator::_traverse_loops(
     
     // append thin walls to the nearest-neighbor search (only for first iteration)
     if (!thin_walls.empty()) {
-        ExtrusionEntityCollection tw = thin_variable_width(thin_walls, erThinWall, this->ext_perimeter_flow);
+        ExtrusionEntityCollection tw = thin_variable_width(thin_walls, erThinWall, this->ext_perimeter_flow, std::max(ext_perimeter_flow.scaled_width() / 4, scale_t(this->print_config->resolution)));
         coll.append(tw.entities);
         thin_walls.clear();
     }
@@ -1631,7 +1641,7 @@ void PerimeterGenerator::_merge_thin_walls(ExtrusionEntityCollection &extrusions
             current_loop = last_loop;
         }
         virtual void use(ExtrusionEntityCollection &collection) override {
-            collection.no_sort = false;
+            collection.set_can_sort_reverse(true, true);
             //for each loop? (or other collections)
             for (ExtrusionEntity *entity : collection.entities)
                 entity->visit(*this);
@@ -1672,7 +1682,7 @@ void PerimeterGenerator::_merge_thin_walls(ExtrusionEntityCollection &extrusions
             searcher.search_result.loop->paths.insert(searcher.search_result.loop->paths.begin() + 1 + searcher.search_result.idx_path, 
                 ExtrusionPath(poly_after, *searcher.search_result.path));
             //create thin wall path exttrusion
-            ExtrusionEntityCollection tws = thin_variable_width({ tw }, erThinWall, this->ext_perimeter_flow);
+            ExtrusionEntityCollection tws = thin_variable_width({ tw }, erThinWall, this->ext_perimeter_flow, std::max(ext_perimeter_flow.scaled_width() / 4, scale_t(this->print_config->resolution)));
             ChangeFlow change_flow;
             if (tws.entities.size() == 1 && tws.entities[0]->is_loop()) {
                 //loop, just add it 
@@ -1708,7 +1718,7 @@ void PerimeterGenerator::_merge_thin_walls(ExtrusionEntityCollection &extrusions
     }
 
     //now add thinwalls that have no anchor (make them reversable)
-    ExtrusionEntityCollection tws = thin_variable_width(not_added, erThinWall, this->ext_perimeter_flow);
+    ExtrusionEntityCollection tws = thin_variable_width(not_added, erThinWall, this->ext_perimeter_flow, std::max(ext_perimeter_flow.scaled_width() / 4, scale_t(this->print_config->resolution)));
     extrusions.append(tws.entities);
 }
 
diff --git a/src/libslic3r/Preset.cpp b/src/libslic3r/Preset.cpp
index d8be8af9e..45eace66b 100644
--- a/src/libslic3r/Preset.cpp
+++ b/src/libslic3r/Preset.cpp
@@ -627,9 +627,10 @@ const std::vector<std::string>& Preset::print_options()
         "thin_walls_overlap",
         "thin_walls_speed",
         "thin_walls_merge",
-        //precision, spoothign
+        //precision, smoothing
         "model_precision",
         "resolution",
+        "resolution_internal",
         "curve_smoothing_precision",
         "curve_smoothing_cutoff_dist",
         "curve_smoothing_angle_convex",
diff --git a/src/libslic3r/Print.cpp b/src/libslic3r/Print.cpp
index 41b52b78a..904ebe45c 100644
--- a/src/libslic3r/Print.cpp
+++ b/src/libslic3r/Print.cpp
@@ -234,9 +234,12 @@ bool Print::invalidate_state_by_config_options(const std::vector<t_config_option
             steps.emplace_back(psBrim);
             steps.emplace_back(psSkirt);
         } else if (
-               opt_key == "nozzle_diameter"
+               opt_key == "filament_shrink"
+            || opt_key == "nozzle_diameter"
+            || opt_key == "model_precision"
             || opt_key == "resolution"
-            || opt_key == "filament_shrink"
+            || opt_key == "resolution_internal"
+            || opt_key == "slice_closing_radius"
             // Spiral Vase forces different kind of slicing than the normal model:
             // In Spiral Vase mode, holes are closed and only the largest area contour is kept at each layer.
             // Therefore toggling the Spiral Vase on / off requires complete reslicing.
@@ -2287,7 +2290,7 @@ void Print::_extrude_brim_from_tree(std::vector<std::vector<BrimLoop>>& loops, c
         } else {
             ExtrusionEntityCollection* print_me_first = new ExtrusionEntityCollection();
             parent->entities.push_back(print_me_first);
-            print_me_first->no_sort = true;
+            print_me_first->set_can_sort_reverse(false, false);
             for (Polyline& line : to_cut.lines)
                 if (line.points.back() == line.points.front()) {
                     ExtrusionPath path(erSkirt, mm3_per_mm, width, height);
diff --git a/src/libslic3r/PrintConfig.cpp b/src/libslic3r/PrintConfig.cpp
index d67c516fd..7d7974457 100644
--- a/src/libslic3r/PrintConfig.cpp
+++ b/src/libslic3r/PrintConfig.cpp
@@ -3364,7 +3364,18 @@ void PrintConfigDef::init_fff_params()
     def->min = 0;
     def->precision = 8;
     def->mode = comExpert;
-    def->set_default_value(new ConfigOptionFloat(0.002));
+    def->set_default_value(new ConfigOptionFloat(0.0125));
+
+    def = this->add("resolution_internal", coFloat);
+    def->label = L("Internal resolution");
+    def->category = OptionCategory::slicing;
+    def->tooltip = L("Minimum detail resolution, used for internal strutures (gapfill and some infill patterns)."
+            "\nDon't put a too small value (0.05mm is way too low for many printers), as it may creates too many very small segments that may difficult to display and print.");
+    def->sidetext = L("mm");
+    def->min = 0.001;
+    def->precision = 8;
+    def->mode = comExpert;
+    def->set_default_value(new ConfigOptionFloat(0.2));
 
     def = this->add("retract_before_travel", coFloats);
     def->label = L("Minimum travel after retraction");
diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp
index 8d5047e62..8e64e70ea 100644
--- a/src/libslic3r/PrintConfig.hpp
+++ b/src/libslic3r/PrintConfig.hpp
@@ -1377,6 +1377,7 @@ public:
     ConfigOptionString              printer_model;
     ConfigOptionString              printer_notes;
     ConfigOptionFloat               resolution;
+    ConfigOptionFloat               resolution_internal;
     ConfigOptionFloats              retract_before_travel;
     ConfigOptionBools               retract_layer_change;
     ConfigOptionInt                 skirt_brim;
@@ -1485,6 +1486,7 @@ protected:
         OPT_PTR(printer_model);
         OPT_PTR(printer_notes);
         OPT_PTR(resolution);
+        OPT_PTR(resolution_internal);
         OPT_PTR(retract_before_travel);
         OPT_PTR(retract_layer_change);
         OPT_PTR(seam_gap);