Merge remote-tracking branch 'remotes/origin/lh_vb_ensurovani' into vb_ensurovani

src/libslic3r/CMakeLists.txt

@@ -72,6 +72,8 @@ set(SLIC3R_SOURCES
     Fill/FillBase.hpp
     Fill/FillConcentric.cpp
     Fill/FillConcentric.hpp
+    Fill/FillEnsuring.cpp
+    Fill/FillEnsuring.hpp
     Fill/FillHoneycomb.cpp
     Fill/FillHoneycomb.hpp
     Fill/FillGyroid.cpp

src/libslic3r/Fill/Fill.cpp

@@ -15,6 +15,7 @@
 #include "FillRectilinear.hpp"
 #include "FillLightning.hpp"
 #include "FillConcentric.hpp"
+#include "FillEnsuring.hpp"
 
 namespace Slic3r {
 
@@ -301,10 +302,10 @@ std::vector<SurfaceFill> group_fills(const Layer &layer)
 		}
     }
 
-	// Detect narrow internal solid infill area and use ipBoundedRectilinear pattern instead.
+	// Detect narrow internal solid infill area and use ipEnsuring pattern instead.
 	{
 		std::vector<char> narrow_expolygons;
-		static constexpr const auto narrow_pattern = ipBoundedRectilinear;
+		static constexpr const auto narrow_pattern = ipEnsuring;
 		for (size_t surface_fill_id = 0, num_old_fills = surface_fills.size(); surface_fill_id < num_old_fills; ++ surface_fill_id)
 			if (SurfaceFill &fill = surface_fills[surface_fill_id]; fill.surface.surface_type == stInternalSolid) {
 				size_t num_expolygons = fill.expolygons.size();
@@ -494,8 +495,8 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
         if (surface_fill.params.pattern == ipLightning)
             dynamic_cast<FillLightning::Filler*>(f.get())->generator = lightning_generator;
 
-        if (surface_fill.params.pattern == ipBoundedRectilinear) {
+        if (surface_fill.params.pattern == ipEnsuring) {
-            auto *fill_bounded_rectilinear = dynamic_cast<FillBoundedRectilinear *>(f.get());
+            auto *fill_bounded_rectilinear = dynamic_cast<FillEnsuring *>(f.get());
             assert(fill_bounded_rectilinear != nullptr);
             fill_bounded_rectilinear->print_region_config = &m_regions[surface_fill.region_id]->region().config();
         }
@@ -527,7 +528,7 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
         params.anchor_length     = surface_fill.params.anchor_length;
         params.anchor_length_max = surface_fill.params.anchor_length_max;
         params.resolution        = resolution;
-        params.use_arachne       = (perimeter_generator == PerimeterGeneratorType::Arachne && surface_fill.params.pattern == ipConcentric) || surface_fill.params.pattern == ipBoundedRectilinear;
+        params.use_arachne       = (perimeter_generator == PerimeterGeneratorType::Arachne && surface_fill.params.pattern == ipConcentric) || surface_fill.params.pattern == ipEnsuring;
         params.layer_height      = layerm.layer()->height;
 
         for (ExPolygon &expoly : surface_fill.expolygons) {

src/libslic3r/Fill/FillBase.cpp

@@ -20,6 +20,7 @@
 #include "FillRectilinear.hpp"
 #include "FillAdaptive.hpp"
 #include "FillLightning.hpp"
+#include "FillEnsuring.hpp"
 
 #include <boost/log/trivial.hpp>
 
@@ -49,7 +50,7 @@ Fill* Fill::new_from_type(const InfillPattern type)
     case ipSupportCubic:        return new FillAdaptive::Filler();
     case ipSupportBase:         return new FillSupportBase();
     case ipLightning:           return new FillLightning::Filler();
-    case ipBoundedRectilinear:  return new FillBoundedRectilinear();
+    case ipEnsuring:            return new FillEnsuring();
     default: throw Slic3r::InvalidArgument("unknown type");
     }
 }

src/libslic3r/Fill/FillBase.hpp

@@ -91,7 +91,7 @@ public:
     // Octree builds on mesh for usage in the adaptive cubic infill
     FillAdaptive::Octree* adapt_fill_octree = nullptr;
 
-    // PrintConfig and PrintObjectConfig are used by infills that use Arachne (Concentric and FillBoundedRectilinear).
+    // PrintConfig and PrintObjectConfig are used by infills that use Arachne (Concentric and FillEnsuring).
     const PrintConfig       *print_config        = nullptr;
     const PrintObjectConfig *print_object_config = nullptr;
 

src/libslic3r/Fill/FillEnsuring.cpp

@@ -0,0 +1,107 @@
+#include "../ClipperUtils.hpp"
+#include "../ShortestPath.hpp"
+#include "../Arachne/WallToolPaths.hpp"
+
+#include "FillEnsuring.hpp"
+
+#include <boost/log/trivial.hpp>
+
+namespace Slic3r {
+
+ThickPolylines FillEnsuring::fill_surface_arachne(const Surface *surface, const FillParams &params)
+{
+    assert(params.use_arachne);
+    assert(this->print_config != nullptr && this->print_object_config != nullptr && this->print_region_config != nullptr);
+
+    const coord_t               scaled_spacing         = scaled<coord_t>(this->spacing);
+    const EnsuringInfillPattern infill_patter          = this->print_object_config->ensure_vertical_shell_infill;
+    const bool                  is_bounded_rectilinear = infill_patter == EnsuringInfillPattern::eipBoundedRectilinear;
+
+    // Perform offset.
+    Slic3r::ExPolygons expp = this->overlap != 0. ? offset_ex(surface->expolygon, scaled<float>(this->overlap)) : ExPolygons{surface->expolygon};
+    // Create the infills for each of the regions.
+    ThickPolylines thick_polylines_out;
+    for (ExPolygon &ex_poly : expp) {
+        Point    bbox_size   = ex_poly.contour.bounding_box().size();
+        coord_t  loops_count = is_bounded_rectilinear ? 1 : std::max(bbox_size.x(), bbox_size.y()) / scaled_spacing + 1;
+        Polygons polygons    = to_polygons(ex_poly);
+        Arachne::WallToolPaths wall_tool_paths(polygons, scaled_spacing, scaled_spacing, loops_count, 0, params.layer_height, *this->print_object_config, *this->print_config);
+        if (std::vector<Arachne::VariableWidthLines> loops = wall_tool_paths.getToolPaths(); !loops.empty()) {
+            assert(!is_bounded_rectilinear || loops.size() == 1);
+            std::vector<const Arachne::ExtrusionLine *> all_extrusions;
+            for (Arachne::VariableWidthLines &loop : loops) {
+                if (loop.empty())
+                    continue;
+                for (const Arachne::ExtrusionLine &wall : loop)
+                    all_extrusions.emplace_back(&wall);
+            }
+
+            // Split paths using a nearest neighbor search.
+            size_t firts_poly_idx = thick_polylines_out.size();
+            Point  last_pos(0, 0);
+            for (const Arachne::ExtrusionLine *extrusion : all_extrusions) {
+                if (extrusion->empty())
+                    continue;
+
+                ThickPolyline thick_polyline = Arachne::to_thick_polyline(*extrusion);
+                if (thick_polyline.length() == 0.)
+                    //FIXME this should not happen.
+                    continue;
+                assert(thick_polyline.size() > 1);
+                assert(thick_polyline.length() > 0.);
+                //assert(thick_polyline.points.size() == thick_polyline.width.size());
+                if (extrusion->is_closed)
+                    thick_polyline.start_at_index(nearest_point_index(thick_polyline.points, last_pos));
+
+                assert(thick_polyline.size() > 1);
+                //assert(thick_polyline.points.size() == thick_polyline.width.size());
+                thick_polylines_out.emplace_back(std::move(thick_polyline));
+                last_pos = thick_polylines_out.back().last_point();
+            }
+
+            // clip the paths to prevent the extruder from getting exactly on the first point of the loop
+            // Keep valid paths only.
+            size_t j = firts_poly_idx;
+            for (size_t i = firts_poly_idx; i < thick_polylines_out.size(); ++i) {
+                assert(thick_polylines_out[i].size() > 1);
+                assert(thick_polylines_out[i].length() > 0.);
+                //assert(thick_polylines_out[i].points.size() == thick_polylines_out[i].width.size());
+                thick_polylines_out[i].clip_end(this->loop_clipping);
+                assert(thick_polylines_out[i].size() > 1);
+                if (thick_polylines_out[i].is_valid()) {
+                    if (j < i)
+                        thick_polylines_out[j] = std::move(thick_polylines_out[i]);
+                    ++j;
+                }
+            }
+            if (j < thick_polylines_out.size())
+                thick_polylines_out.erase(thick_polylines_out.begin() + int(j), thick_polylines_out.end());
+        }
+
+        if (is_bounded_rectilinear) {
+            // Remaining infill area will be filled with classic Rectilinear infill.
+            ExPolygons infill_contour = union_ex(wall_tool_paths.getInnerContour());
+            if (offset_ex(infill_contour, -float(scaled_spacing / 2.)).empty())
+                infill_contour.clear(); // Infill region is too small, so let's filter it out.
+
+            Polygons pp;
+            for (ExPolygon &ex : infill_contour)
+                ex.simplify_p(scaled<double>(params.resolution), &pp);
+
+            // Collapse too narrow infill areas and append them to thick_polylines_out.
+            const auto min_perimeter_infill_spacing = coord_t(scaled_spacing * (1. - INSET_OVERLAP_TOLERANCE));
+            const auto infill_overlap               = coord_t(scale_(this->print_region_config->get_abs_value("infill_overlap", this->spacing)));
+            for (ExPolygon &ex_poly : offset2_ex(union_ex(pp), float(-min_perimeter_infill_spacing / 2.), float(infill_overlap + min_perimeter_infill_spacing / 2.))) {
+                Polylines polylines;
+                if (Surface new_surface(*surface, std::move(ex_poly)); !fill_surface_by_lines(&new_surface, params, 0.f, 0.f, polylines))
+                    BOOST_LOG_TRIVIAL(error) << "FillBoundedRectilinear::fill_surface() failed to fill a region.";
+                append(thick_polylines_out, to_thick_polylines(std::move(polylines), scaled<coord_t>(this->spacing)));
+            }
+        } else
+            assert(infill_patter == EnsuringInfillPattern::eipConcentric);
+    }
+
+    return thick_polylines_out;
+}
+
+} // namespace Slic3r

src/libslic3r/Fill/FillEnsuring.hpp

@@ -0,0 +1,30 @@
+#ifndef slic3r_FillEnsuring_hpp_
+#define slic3r_FillEnsuring_hpp_
+
+#include "FillBase.hpp"
+#include "FillRectilinear.hpp"
+
+namespace Slic3r {
+
+class FillEnsuring : public FillRectilinear
+{
+public:
+    Fill *clone() const override { return new FillEnsuring(*this); }
+    ~FillEnsuring() override = default;
+    Polylines      fill_surface(const Surface *surface, const FillParams &params) override { return {}; };
+    ThickPolylines fill_surface_arachne(const Surface *surface, const FillParams &params) override;
+
+protected:
+    void fill_surface_single_arachne(const Surface &surface, const FillParams &params, ThickPolylines &thick_polylines_out);
+
+    bool no_sort() const override { return true; }
+
+    // PrintRegionConfig is used for computing overlap between boundary contour and inner Rectilinear infill.
+    const PrintRegionConfig *print_region_config = nullptr;
+
+    friend class Layer;
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_FillEnsuring_hpp_

src/libslic3r/Fill/FillRectilinear.cpp

@@ -15,7 +15,6 @@
 #include "../Geometry.hpp"
 #include "../Surface.hpp"
 #include "../ShortestPath.hpp"
-#include "../Arachne/WallToolPaths.hpp"
 
 #include "FillRectilinear.hpp"
 
@@ -3044,90 +3043,6 @@ Polylines FillSupportBase::fill_surface(const Surface *surface, const FillParams
     return polylines_out;
 }
 
-ThickPolylines FillBoundedRectilinear::fill_surface_arachne(const Surface *surface, const FillParams &params)
-{
-    // Perform offset.
-    Slic3r::ExPolygons expp = offset_ex(surface->expolygon, float(scale_(this->overlap - 0.5 * this->spacing)));
-    // Create the infills for each of the regions.
-    ThickPolylines thick_polylines_out;
-    for (ExPolygon &ex_poly : expp)
-        fill_surface_single_arachne(Surface(*surface, std::move(ex_poly)), params, thick_polylines_out);
-
-    return thick_polylines_out;
-}
-
-void FillBoundedRectilinear::fill_surface_single_arachne(const Surface &surface, const FillParams &params, ThickPolylines &thick_polylines_out)
-{
-    assert(params.use_arachne);
-    assert(this->print_config != nullptr && this->print_object_config != nullptr && this->print_region_config != nullptr);
-
-    coord_t                scaled_spacing = scaled<coord_t>(this->spacing);
-    Polygons               polygons       = offset(surface.expolygon, float(scaled_spacing) / 2.f);
-    Arachne::WallToolPaths wall_tool_paths(polygons, scaled_spacing, scaled_spacing, 1, 0, params.layer_height, *this->print_object_config, *this->print_config);
-    if (std::vector<Arachne::VariableWidthLines> loop = wall_tool_paths.getToolPaths(); !loop.empty()) {
-        assert(loop.size() == 1);
-
-        size_t firts_poly_idx = thick_polylines_out.size();
-        Point  last_pos(0, 0);
-        for (const Arachne::ExtrusionLine &extrusion : loop.front()) {
-            if (extrusion.empty())
-                continue;
-
-            ThickPolyline thick_polyline = Arachne::to_thick_polyline(extrusion);
-            if (thick_polyline.length() == 0.)
-                //FIXME this should not happen.
-                continue;
-            assert(thick_polyline.size() > 1);
-            assert(thick_polyline.length() > 0.);
-            //assert(thick_polyline.points.size() == thick_polyline.width.size());
-            if (extrusion.is_closed)
-                thick_polyline.start_at_index(nearest_point_index(thick_polyline.points, last_pos));
-
-            assert(thick_polyline.size() > 1);
-            //assert(thick_polyline.points.size() == thick_polyline.width.size());
-            thick_polylines_out.emplace_back(std::move(thick_polyline));
-            last_pos = thick_polylines_out.back().last_point();
-        }
-
-        // clip the paths to prevent the extruder from getting exactly on the first point of the loop
-        // Keep valid paths only.
-        size_t j = firts_poly_idx;
-        for (size_t i = firts_poly_idx; i < thick_polylines_out.size(); ++i) {
-            assert(thick_polylines_out[i].size() > 1);
-            assert(thick_polylines_out[i].length() > 0.);
-            //assert(thick_polylines_out[i].points.size() == thick_polylines_out[i].width.size());
-            thick_polylines_out[i].clip_end(this->loop_clipping);
-            assert(thick_polylines_out[i].size() > 1);
-            if (thick_polylines_out[i].is_valid()) {
-                if (j < i)
-                    thick_polylines_out[j] = std::move(thick_polylines_out[i]);
-                ++j;
-            }
-        }
-        if (j < thick_polylines_out.size())
-            thick_polylines_out.erase(thick_polylines_out.begin() + int(j), thick_polylines_out.end());
-    }
-
-    // Remaining infill area will be filled with classic Rectilinear infill.
-    ExPolygons infill_contour = union_ex(wall_tool_paths.getInnerContour());
-    if (offset_ex(infill_contour, -float(scaled_spacing / 2.)).empty())
-        infill_contour.clear(); // Infill region is too small, so let's filter it out.
-
-    Polygons pp;
-    for (ExPolygon &ex : infill_contour)
-        ex.simplify_p(scaled<double>(params.resolution), &pp);
-
-    // Collapse too narrow infill areas and append them to thick_polylines_out.
-    const auto min_perimeter_infill_spacing = coord_t(scaled_spacing * (1. - INSET_OVERLAP_TOLERANCE));
-    const auto infill_overlap = coord_t(scale_(this->print_region_config->get_abs_value("infill_overlap", this->spacing)));
-    for (ExPolygon &ex_poly : offset2_ex(union_ex(pp), float(-min_perimeter_infill_spacing / 2.), float(infill_overlap + min_perimeter_infill_spacing / 2.))) {
-        Polylines polylines;
-        if (Surface new_surface(surface, std::move(ex_poly)); !fill_surface_by_lines(&new_surface, params, 0.f, 0.f, polylines))
-            BOOST_LOG_TRIVIAL(error) << "FillBoundedRectilinear::fill_surface() failed to fill a region.";
-        append(thick_polylines_out, to_thick_polylines(std::move(polylines), scaled<coord_t>(this->spacing)));
-    }
-}
-
 // Lightning infill assumes that the distance between any two sampled points is always
 // at least equal to the value of spacing. To meet this assumption, we need to use
 // BoundingBox for whole layers instead of bounding box just around processing ExPolygon.

src/libslic3r/Fill/FillRectilinear.hpp

@@ -110,25 +110,6 @@ protected:
     float _layer_angle(size_t idx) const override { return 0.f; }
 };
 
-class FillBoundedRectilinear : public FillRectilinear
-{
-public:
-    Fill *clone() const override { return new FillBoundedRectilinear(*this); }
-    ~FillBoundedRectilinear() override = default;
-    Polylines      fill_surface(const Surface *surface, const FillParams &params) override { return {}; };
-    ThickPolylines fill_surface_arachne(const Surface *surface, const FillParams &params) override;
-
-protected:
-    void fill_surface_single_arachne(const Surface &surface, const FillParams &params, ThickPolylines &thick_polylines_out);
-
-    bool no_sort() const override { return true; }
-
-    // PrintRegionConfig is used for computing overlap between boundary contour and inner Rectilinear infill.
-    const PrintRegionConfig *print_region_config = nullptr;
-
-    friend class Layer;
-};
-
 Points sample_grid_pattern(const ExPolygon &expolygon, coord_t spacing, const BoundingBox &global_bounding_box);
 Points sample_grid_pattern(const ExPolygons &expolygons, coord_t spacing, const BoundingBox &global_bounding_box);
 Points sample_grid_pattern(const Polygons &polygons, coord_t spacing, const BoundingBox &global_bounding_box);

src/libslic3r/Preset.cpp

@@ -449,7 +449,7 @@ static std::vector<std::string> s_Preset_print_options {
     "wipe_tower_width", "wipe_tower_rotation_angle", "wipe_tower_brim_width", "wipe_tower_bridging", "single_extruder_multi_material_priming", "mmu_segmented_region_max_width",
     "wipe_tower_no_sparse_layers", "compatible_printers", "compatible_printers_condition", "inherits",
     "perimeter_generator", "wall_transition_length", "wall_transition_filter_deviation", "wall_transition_angle",
-    "wall_distribution_count", "min_feature_size", "min_bead_width"
+    "wall_distribution_count", "min_feature_size", "min_bead_width", "ensure_vertical_shell_infill"
 };
 
 static std::vector<std::string> s_Preset_filament_options {

src/libslic3r/PrintConfig.cpp

@@ -220,6 +220,12 @@ static t_config_enum_values s_keys_map_PerimeterGeneratorType {
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(PerimeterGeneratorType)
 
+static t_config_enum_values s_keys_map_EnsuringInfillPattern {
+    { "bounded_rectilinear", int(EnsuringInfillPattern::eipBoundedRectilinear) },
+    { "concentric", int(EnsuringInfillPattern::eipConcentric) }
+};
+CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(EnsuringInfillPattern)
+
 static void assign_printer_technology_to_unknown(t_optiondef_map &options, PrinterTechnology printer_technology)
 {
     for (std::pair<const t_config_option_key, ConfigOptionDef> &kvp : options)
@@ -3214,6 +3220,18 @@ void PrintConfigDef::init_fff_params()
     def->min = 0;
     def->set_default_value(new ConfigOptionFloatOrPercent(85, true));
 
+    def = this->add("ensure_vertical_shell_infill", coEnum);
+    def->label = L("Ensure vertical shell infill");
+    def->category = L("Layers and Perimeters");
+    def->tooltip = L("Ensure vertical shell infill.");
+    def->enum_keys_map = &ConfigOptionEnum<EnsuringInfillPattern>::get_enum_values();
+    def->enum_values.push_back("bounded_rectilinear");
+    def->enum_values.push_back("concentric");
+    def->enum_labels.push_back(L("Bounded Rectilinear"));
+    def->enum_labels.push_back(L("Concentric"));
+    def->mode = comAdvanced;
+    def->set_default_value(new ConfigOptionEnum<EnsuringInfillPattern>(EnsuringInfillPattern::eipBoundedRectilinear));
+
     // Declare retract values for filament profile, overriding the printer's extruder profile.
     for (const char *opt_key : {
         // floats

src/libslic3r/PrintConfig.hpp

@@ -60,7 +60,7 @@ enum InfillPattern : int {
     ipRectilinear, ipMonotonic, ipAlignedRectilinear, ipGrid, ipTriangles, ipStars, ipCubic, ipLine, ipConcentric, ipHoneycomb, ip3DHoneycomb,
     ipGyroid, ipHilbertCurve, ipArchimedeanChords, ipOctagramSpiral, ipAdaptiveCubic, ipSupportCubic, ipSupportBase,
     ipLightning,
-    ipBoundedRectilinear,
+    ipEnsuring,
     ipCount,
 };
 
@@ -133,6 +133,11 @@ enum class PerimeterGeneratorType
     Arachne
 };
 
+enum class EnsuringInfillPattern {
+    eipBoundedRectilinear,
+    eipConcentric
+};
+
 enum class GCodeThumbnailsFormat {
     PNG, JPG, QOI
 };
@@ -162,6 +167,8 @@ CONFIG_OPTION_ENUM_DECLARE_STATIC_MAPS(DraftShield)
 CONFIG_OPTION_ENUM_DECLARE_STATIC_MAPS(GCodeThumbnailsFormat)
 CONFIG_OPTION_ENUM_DECLARE_STATIC_MAPS(ForwardCompatibilitySubstitutionRule)
 CONFIG_OPTION_ENUM_DECLARE_STATIC_MAPS(PerimeterGeneratorType)
+CONFIG_OPTION_ENUM_DECLARE_STATIC_MAPS(EnsuringInfillPattern)
+
 
 #undef CONFIG_OPTION_ENUM_DECLARE_STATIC_MAPS
 
@@ -490,6 +497,7 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionBool,                clip_multipart_objects))
     ((ConfigOptionBool,                dont_support_bridges))
     ((ConfigOptionFloat,               elefant_foot_compensation))
+    ((ConfigOptionEnum<EnsuringInfillPattern>, ensure_vertical_shell_infill))
     ((ConfigOptionFloatOrPercent,      extrusion_width))
     ((ConfigOptionFloat,               first_layer_acceleration_over_raft))
     ((ConfigOptionFloatOrPercent,      first_layer_speed_over_raft))

src/libslic3r/PrintObject.cpp

@@ -751,7 +751,8 @@ bool PrintObject::invalidate_state_by_config_options(
             || opt_key == "wall_transition_angle"
             || opt_key == "wall_distribution_count"
             || opt_key == "min_feature_size"
-            || opt_key == "min_bead_width") {
+            || opt_key == "min_bead_width"
+            || opt_key == "ensure_vertical_shell_infill") {
             steps.emplace_back(posSlice);
         } else if (
                opt_key == "seam_position"

src/slic3r/GUI/Tab.cpp

@@ -1425,6 +1425,7 @@ void TabPrint::build()
         optgroup->append_single_option_line("extra_perimeters", category_path + "extra-perimeters-if-needed");
         optgroup->append_single_option_line("extra_perimeters_on_overhangs", category_path + "extra-perimeters-on-overhangs");
         optgroup->append_single_option_line("ensure_vertical_shell_thickness", category_path + "ensure-vertical-shell-thickness");
+        optgroup->append_single_option_line("ensure_vertical_shell_infill");
         optgroup->append_single_option_line("avoid_curled_filament_during_travels", category_path + "avoid-curled-filament-during-travels");
         optgroup->append_single_option_line("avoid_crossing_perimeters", category_path + "avoid-crossing-perimeters");
         optgroup->append_single_option_line("avoid_crossing_perimeters_max_detour", category_path + "avoid_crossing_perimeters_max_detour");