CURA-12996 Fix flooring areas being generated when disabled (#2302)

Author: HellAholic

include/skin.h

@@ -120,6 +120,13 @@ class SkinInfillAreaComputation
      */
     void applySkinExpansion(const Shape& original_outline, Shape& upskin, Shape& downskin);
 
+    /*!
+     * Allow small gaps in infill areas to grow over infill areas. This helps keeping the skin areas consistent.
+     * @param skin[in, out] The skin area to be possibly expanded
+     * @param infill[in, out] The infill area to be possibly shrunk
+     */
+    void applySkinFillSmallInfillGaps(Shape& skin, Shape& infill) const;
+
     /*!
      * Generate infill of a given part
      * \param[in,out] part The part where the wall information (input) is retrieved and

src/skin.cpp

@@ -151,6 +151,9 @@ void SkinInfillAreaComputation::generateSkinAndInfillAreas(SliceLayerPart& part)
     skin.removeSmallAreas(MIN_AREA_SIZE);
     // Create infill area irrespective if the infill is to be generated or not(would be used for bridging).
     part.infill_area = part.inner_area.difference(skin);
+
+    applySkinFillSmallInfillGaps(skin, part.infill_area);
+
     if (process_infill_)
     { // process infill when infill density > 0
         // or when other infill meshes want to modify this infill
@@ -308,6 +311,22 @@ void SkinInfillAreaComputation::applySkinExpansion(const Shape& original_outline
     }
 }
 
+void SkinInfillAreaComputation::applySkinFillSmallInfillGaps(Shape& skin, Shape& infill) const
+{
+    // First do an opening to close the small gaps within the skin
+    const coord_t opening_offset = skin_line_width_ * 2;
+    const Shape opened_skin = skin.offset(opening_offset).offset(-opening_offset - EPSILON);
+
+    // Now extract the filled gaps by removing the initial skin
+    const Shape filled_areas = opened_skin.difference(skin);
+    // Only keep the filled gaps that overlap infill areas
+    const Shape filled_areas_over_infill = filled_areas.intersection(infill).offset(EPSILON);
+
+    // Expand skin and shrink infill with the filled gaps
+    skin = skin.unionPolygons(filled_areas_over_infill);
+    infill = infill.difference(filled_areas_over_infill);
+}
+
 /*
  * This function is executed in a parallel region based on layer_nr.
  * When modifying make sure any changes does not introduce data races.
@@ -329,24 +348,32 @@ void SkinInfillAreaComputation::generateInfill(SliceLayerPart& part)
 void SkinInfillAreaComputation::generateSkinRoofingFlooringFill(SliceLayerPart& part)
 {
     const size_t roofing_layer_count = std::min(mesh_.settings.get<size_t>("roofing_layer_count"), mesh_.settings.get<size_t>("top_layers"));
+    const bool has_roofing = roofing_layer_count > 0;
     const size_t flooring_layer_count = std::min(mesh_.settings.get<size_t>("flooring_layer_count"), mesh_.settings.get<size_t>("bottom_layers"));
+    const bool has_flooring = flooring_layer_count > 0;
     const coord_t skin_overlap = mesh_.settings.get<coord_t>("skin_overlap_mm");
     const coord_t roofing_expansion = mesh_.settings.get<coord_t>("roofing_expansion");
 
-    constexpr coord_t epsilon = 5;
     const SliceDataStorage slice_data;
     const Shape build_plate = slice_data.getRawMachineBorder();
 
-    const Shape filled_area_above = generateFilledAreaAbove(part, roofing_layer_count);
-    const Shape filled_area_below = generateFilledAreaBelow(part, flooring_layer_count).value_or(build_plate.offset(epsilon));
+    const Shape filled_area_above = has_roofing ? generateFilledAreaAbove(part, roofing_layer_count) : build_plate;
+    const Shape filled_area_below = has_flooring ? (generateFilledAreaBelow(part, flooring_layer_count).value_or(build_plate)) : build_plate;
 
     for (SkinPart& skin_part : part.skin_parts)
     {
-        const Shape below_inside = skin_part.outline.intersection(filled_area_below);
-        const Shape above_inside = skin_part.outline.intersection(filled_area_above);
+        if (has_roofing)
+        {
+            const Shape below_inside = skin_part.outline.intersection(filled_area_below);
+            skin_part.roofing_fill = below_inside.difference(filled_area_above).offset(roofing_expansion).intersection(below_inside);
+        }
+
+        if (has_flooring)
+        {
+            const Shape above_inside = skin_part.outline.intersection(filled_area_above);
+            skin_part.flooring_fill = above_inside.difference(filled_area_below);
+        }
 
-        skin_part.roofing_fill = below_inside.difference(filled_area_above).offset(roofing_expansion).intersection(below_inside);
-        skin_part.flooring_fill = above_inside.difference(filled_area_below);
         skin_part.skin_fill = skin_part.outline.difference(skin_part.roofing_fill).intersection(filled_area_below);
 
         // We remove offsets areas from roofing and flooring anywhere they overlap with skin_fill.