Merge pull request #1352 from Ultimaker/CURA-7804_Fill_gaps_between_walls_fills_gaps_between_skin_and_infill4.8.04.84.8

Fill gaps between walls fills gaps between skin and infill

4 files changed, 39 insertions, 53 deletions

diff --git a/src/FffGcodeWriter.cpp b/src/FffGcodeWriter.cpp
index 19411af0e..fff2a4021 100644
--- a/src/FffGcodeWriter.cpp
+++ b/src/FffGcodeWriter.cpp
@@ -1658,10 +1658,7 @@ bool FffGcodeWriter::processSingleLayerInfill(const SliceDataStorage& storage, L
 
             if (infill_below_skin.size())
             {
-                // need to take skin/infill overlap that was added in SkinInfillAreaComputation::generateInfill() into account
-                const coord_t infill_skin_overlap = mesh.settings.get<coord_t>((part.insets.size() > 1) ? "wall_line_width_x" : "wall_line_width_0") / 2;
-
-                if (infill_below_skin.offset(-(infill_skin_overlap + tiny_infill_offset)).size())
+                if (!infill_below_skin.offset(-tiny_infill_offset).empty())
                 {
                     // there is infill below skin, is there also infill that isn't below skin?
                     Polygons infill_not_below_skin = in_outline.difference(infill_below_skin);
diff --git a/src/FffPolygonGenerator.cpp b/src/FffPolygonGenerator.cpp
index 283a07e1e..c2c8a2fcf 100644
--- a/src/FffPolygonGenerator.cpp
+++ b/src/FffPolygonGenerator.cpp
@@ -571,6 +571,7 @@ void FffPolygonGenerator::processPerimeterGaps(SliceDataStorage& storage)
             coord_t wall_line_width_0 = mesh.settings.get<coord_t>("wall_line_width_0");
             coord_t wall_line_width_x = mesh.settings.get<coord_t>("wall_line_width_x");
             coord_t skin_line_width = mesh.settings.get<coord_t>("skin_line_width");
+            coord_t infill_line_width = mesh.settings.get<coord_t>("infill_line_width");
             if (layer_nr == 0)
             {
                 const ExtruderTrain& train_wall_0 = mesh.settings.get<ExtruderTrain&>("wall_0_extruder_nr");
@@ -616,9 +617,13 @@ void FffPolygonGenerator::processPerimeterGaps(SliceDataStorage& storage)
                         // we print them as a perimeter gap
                         inner = inner.offset(-skin_line_width / 2).offset(skin_line_width / 2);
                     }
-                    inner.add(part.infill_area);
+                    inner.add(part.infill_area.offset(-infill_line_width / 2).offset(infill_line_width / 2));
                     inner = inner.unionPolygons();
                     part.perimeter_gaps.add(outer.difference(inner));
+
+                    if (filter_out_tiny_gaps) {
+                        part.perimeter_gaps.removeSmallAreas(2 * INT2MM(infill_line_width) * INT2MM(infill_line_width));
+                    }
                 }
 
                 // add perimeter gaps for skin insets
diff --git a/src/skin.cpp b/src/skin.cpp
index 1c1727fe2..b9c51a3da 100644
--- a/src/skin.cpp
+++ b/src/skin.cpp
@@ -49,20 +49,6 @@ coord_t SkinInfillAreaComputation::getWallLineWidthX(const SliceMeshStorage& mes
     }
     return wall_line_width_x;
 }
-coord_t SkinInfillAreaComputation::getInfillSkinOverlap(const SliceMeshStorage& mesh, const LayerIndex& layer_nr, const coord_t& innermost_wall_line_width)
-{
-    coord_t infill_skin_overlap = 0;
-    { // compute infill_skin_overlap
-        const ExtruderTrain& train_infill = mesh.settings.get<ExtruderTrain&>("infill_extruder_nr");
-        const Ratio infill_line_width_factor = (layer_nr == 0) ? train_infill.settings.get<Ratio>("initial_layer_line_width_factor") : Ratio(1.0);
-        const bool infill_is_dense = mesh.settings.get<coord_t>("infill_line_distance") < mesh.settings.get<coord_t>("infill_line_width") * infill_line_width_factor + 10;
-        if (!infill_is_dense && mesh.settings.get<EFillMethod>("infill_pattern") != EFillMethod::CONCENTRIC)
-        {
-            infill_skin_overlap = innermost_wall_line_width / 2;
-        }
-    }
-    return infill_skin_overlap;
-}
 
 SkinInfillAreaComputation::SkinInfillAreaComputation(const LayerIndex& layer_nr, SliceMeshStorage& mesh, bool process_infill)
 : layer_nr(layer_nr)
@@ -75,7 +61,6 @@ SkinInfillAreaComputation::SkinInfillAreaComputation(const LayerIndex& layer_nr,
 , wall_line_width_0(getWallLineWidth0(mesh, layer_nr))
 , wall_line_width_x(getWallLineWidthX(mesh, layer_nr))
 , innermost_wall_line_width((wall_line_count == 1) ? wall_line_width_0 : wall_line_width_x)
-, infill_skin_overlap(getInfillSkinOverlap(mesh, layer_nr, innermost_wall_line_width))
 , skin_inset_count(mesh.settings.get<size_t>("skin_outline_count"))
 , no_small_gaps_heuristic(mesh.settings.get<bool>("skin_no_small_gaps_heuristic"))
 , process_infill(process_infill)
@@ -428,43 +413,44 @@ void SkinInfillAreaComputation::generateInfill(SliceLayerPart& part, const Polyg
     {
         return; // the last wall is not present, the part should only get inter perimeter gaps, but no infill.
     }
-    const size_t wall_line_count = mesh.settings.get<size_t>("wall_line_count");
-    const coord_t infill_line_distance = mesh.settings.get<coord_t>("infill_line_distance");
 
-    coord_t offset_from_inner_wall = -infill_skin_overlap;
-    if (wall_line_count > 0)
-    { // calculate offset_from_inner_wall
-        coord_t extra_perimeter_offset = 0; // to align concentric polygons across layers
-        const EFillMethod fill_pattern = mesh.settings.get<EFillMethod>("infill_pattern");
-        if (fill_pattern == EFillMethod::CONCENTRIC
-            && infill_line_distance > mesh.settings.get<coord_t>("infill_line_width") * 2)
-        {
-            if (mesh.settings.get<bool>("alternate_extra_perimeter")
-                && layer_nr % 2 == 0)
-            { // compensate shifts otherwise caused by alternating an extra perimeter
-                extra_perimeter_offset = -innermost_wall_line_width;
-            }
-            if (layer_nr == 0)
-            { // compensate for shift caused by walls being expanded by the initial line width multiplier
-                const coord_t normal_wall_line_width_0 = mesh.settings.get<coord_t>("wall_line_width_0");
-                const coord_t normal_wall_line_width_x = mesh.settings.get<coord_t>("wall_line_width_x");
-                const coord_t normal_walls_width = normal_wall_line_width_0 + (wall_line_count - 1) * normal_wall_line_width_x;
-                const coord_t walls_width = normal_walls_width * mesh.settings.get<Ratio>("initial_layer_line_width_factor");
-                extra_perimeter_offset += walls_width - normal_walls_width;
-                while (extra_perimeter_offset > 0)
-                {
-                    extra_perimeter_offset -= infill_line_distance;
+    auto get_offset = [this]()
+    {
+        const auto infill_line_distance = mesh.settings.get<coord_t>("infill_line_distance");
+        if (wall_line_count > 0)
+        { // calculate offset_from_inner_wall
+            coord_t extra_perimeter_offset = 0; // to align concentric polygons across layers
+            const auto fill_pattern = mesh.settings.get<EFillMethod>("infill_pattern");
+            if (fill_pattern == EFillMethod::CONCENTRIC
+                && infill_line_distance > mesh.settings.get<coord_t>("infill_line_width") * 2)
+            {
+                if (mesh.settings.get<bool>("alternate_extra_perimeter")
+                    && layer_nr % 2 == 0)
+                { // compensate shifts otherwise caused by alternating an extra perimeter
+                    extra_perimeter_offset = -innermost_wall_line_width;
+                }
+                if (layer_nr == 0)
+                { // compensate for shift caused by walls being expanded by the initial line width multiplier
+                    const auto normal_wall_line_width_0 = mesh.settings.get<coord_t>("wall_line_width_0");
+                    const auto normal_wall_line_width_x = mesh.settings.get<coord_t>("wall_line_width_x");
+                    const coord_t normal_walls_width = normal_wall_line_width_0 + (wall_line_count - 1) * normal_wall_line_width_x;
+                    const coord_t walls_width = normal_walls_width * mesh.settings.get<Ratio>("initial_layer_line_width_factor");
+                    extra_perimeter_offset += walls_width - normal_walls_width;
+                    while (extra_perimeter_offset > 0)
+                    {
+                        extra_perimeter_offset -= infill_line_distance;
+                    }
                 }
             }
+            return extra_perimeter_offset - innermost_wall_line_width / 2;
         }
-        offset_from_inner_wall += extra_perimeter_offset - innermost_wall_line_width / 2;
-    }
-    Polygons infill = part.insets.back().offset(offset_from_inner_wall);
+        return coord_t(0);
+    };
 
-    infill = infill.difference(skin.offset(infill_skin_overlap));
-    infill.removeSmallAreas(MIN_AREA_SIZE);
+    const coord_t offset_from_inner_wall = get_offset();
 
-    part.infill_area = infill.offset(infill_skin_overlap);
+    part.infill_area = part.insets.back().offset(offset_from_inner_wall).difference(skin);
+    part.infill_area.removeSmallAreas(MIN_AREA_SIZE);
 }
 
 /*
diff --git a/src/skin.h b/src/skin.h
index 46dd1ea47..123166b08 100644
--- a/src/skin.h
+++ b/src/skin.h
@@ -186,7 +186,6 @@ protected:
     const coord_t wall_line_width_0; //!< The line width of the outer wall
     const coord_t wall_line_width_x; //!< The line width of the inner most wall
     const coord_t innermost_wall_line_width; //!< width of the innermost wall lines
-    const coord_t infill_skin_overlap; //!< overlap distance between infill and skin
     const size_t skin_inset_count; //!< The number of perimeters to surround the skin
     const bool no_small_gaps_heuristic; //!< A heuristic which assumes there will be no small gaps between bottom and top skin with a z size smaller than the skin size itself
     const bool process_infill; //!< Whether to process infill, i.e. whether there's a positive infill density or there are infill meshes modifying this mesh.
@@ -201,7 +200,6 @@ private:
     static coord_t getSkinLineWidth(const SliceMeshStorage& mesh, const LayerIndex& layer_nr); //!< Compute the skin line width, which might be different for the first layer.
     static coord_t getWallLineWidth0(const SliceMeshStorage& mesh, const LayerIndex& layer_nr); //!< Compute the outer wall line width, which might be different for the first layer
     static coord_t getWallLineWidthX(const SliceMeshStorage& mesh, const LayerIndex& layer_nr); //!< Compute the inner wall line widths, which might be different for the first layer
-    static coord_t getInfillSkinOverlap(const SliceMeshStorage& mesh, const LayerIndex& layer_nr, const coord_t& innermost_wall_line_width); //!< Compute the infill_skin_overlap
 
     /*!
      * Helper function to get the walls of each part which might intersect with \p part_here