Introduce setting "Inner Wall Inset"

CURA-13281

Author: casperlamboo

CMakeLists.txt

@@ -102,6 +102,7 @@ set(engine_SRCS # Except main.cpp.
         src/BeadingStrategy/RedistributeBeadingStrategy.cpp
         src/BeadingStrategy/WideningBeadingStrategy.cpp
         src/BeadingStrategy/OuterWallInsetBeadingStrategy.cpp
+        src/BeadingStrategy/InnerWallInsetBeadingStrategy.cpp
 
         src/bridge/bridge.cpp
         src/bridge/ExpansionRange.cpp

include/BeadingStrategy/BeadingStrategyFactory.h

@@ -27,6 +27,7 @@ class BeadingStrategyFactory
         const Ratio wall_add_middle_threshold = 0.5_r,
         const coord_t max_bead_count = 0,
         const coord_t outer_wall_offset = 0,
+        const coord_t inner_wall_offset = 0,
         const int inward_distributed_center_wall_count = 2,
         const Ratio minimum_variable_line_ratio = 0.5);
 };

include/BeadingStrategy/InnerWallInsetBeadingStrategy.h

@@ -0,0 +1,35 @@
+// Copyright (c) 2020 Ultimaker B.V.
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#ifndef INNER_WALL_INSET_BEADING_STRATEGY_H
+#define INNER_WALL_INSET_BEADING_STRATEGY_H
+
+#include "BeadingStrategy.h"
+
+namespace cura
+{
+/*
+ * This is a meta strategy that allows for the outer wall to be inset towards the inside of the model.
+ */
+class InnerWallInsetBeadingStrategy : public BeadingStrategy
+{
+public:
+    InnerWallInsetBeadingStrategy(coord_t inner_wall_offset, BeadingStrategyPtr parent);
+
+    virtual ~InnerWallInsetBeadingStrategy() = default;
+
+    Beading compute(coord_t thickness, coord_t bead_count) const override;
+
+    coord_t getOptimalThickness(coord_t bead_count) const override;
+    coord_t getTransitionThickness(coord_t lower_bead_count) const override;
+    coord_t getOptimalBeadCount(coord_t thickness) const override;
+    coord_t getTransitioningLength(coord_t lower_bead_count) const override;
+
+    std::string toString() const override;
+
+private:
+    BeadingStrategyPtr parent_;
+    coord_t inner_wall_offset_;
+};
+} // namespace cura
+#endif // INNER_WALL_INSET_BEADING_STRATEGY_H

include/WallToolPaths.h

@@ -20,13 +20,15 @@ class WallToolPaths
      * \param nominal_bead_width The nominal bead width used in the generation of the toolpaths
      * \param inset_count The maximum number of parallel extrusion lines that make up the wall
      * \param wall_0_inset How far to inset the outer wall, to make it adhere better to other walls.
+     * \param wall_x_inset How far to inset the inner walls, to make it adhere better to other walls.
      * \param settings The settings as provided by the user
      */
     WallToolPaths(
         const Shape& outline,
         const coord_t nominal_bead_width,
         const size_t inset_count,
         const coord_t wall_0_inset,
+        const coord_t wall_x_inset,
         const Settings& settings,
         const int layer_idx,
         SectionType section_type);
@@ -38,6 +40,7 @@ class WallToolPaths
      * \param bead_width_x The bead width of the inner walls used in the generation of the toolpaths
      * \param inset_count The maximum number of parallel extrusion lines that make up the wall
      * \param wall_0_inset How far to inset the outer wall, to make it adhere better to other walls.
+     * \param wall_x_inset How far to inset the inner walls, to make it adhere better to other walls.
      * \param settings The settings as provided by the user
      */
     WallToolPaths(
@@ -46,6 +49,7 @@ class WallToolPaths
         const coord_t bead_width_x,
         const size_t inset_count,
         const coord_t wall_0_inset,
+        const coord_t wall_x_inset,
         const Settings& settings,
         const int layer_idx,
         SectionType section_type);
@@ -125,6 +129,7 @@ class WallToolPaths
                            // this is the same as bead_width_0
     size_t inset_count_; //<! The maximum number of walls to generate
     coord_t wall_0_inset_; //<! How far to inset the outer wall. Should only be applied when printing the actual walls, not extra infill/skin/support walls.
+    coord_t wall_x_inset_; //<! How far to inset the inner walls
     bool print_thin_walls_; //<! Whether to enable the widening beading meta-strategy for thin features
     coord_t min_feature_size_; //<! The minimum size of the features that can be widened by the widening beading meta-strategy. Features thinner than that will not be printed
     coord_t min_bead_width_; //<! The minimum bead size to use when widening thin model features with the widening beading meta-strategy

src/BeadingStrategy/BeadingStrategyFactory.cpp

@@ -10,6 +10,7 @@
 #include "BeadingStrategy/DistributedBeadingStrategy.h"
 #include "BeadingStrategy/LimitedBeadingStrategy.h"
 #include "BeadingStrategy/OuterWallInsetBeadingStrategy.h"
+#include "BeadingStrategy/InnerWallInsetBeadingStrategy.h"
 #include "BeadingStrategy/RedistributeBeadingStrategy.h"
 #include "BeadingStrategy/WideningBeadingStrategy.h"
 
@@ -28,6 +29,7 @@ BeadingStrategyPtr BeadingStrategyFactory::makeStrategy(
     const Ratio wall_add_middle_threshold,
     const coord_t max_bead_count,
     const coord_t outer_wall_offset,
+    const coord_t inner_wall_offset,
     const int inward_distributed_center_wall_count,
     const Ratio minimum_variable_line_ratio)
 {
@@ -53,6 +55,11 @@ BeadingStrategyPtr BeadingStrategyFactory::makeStrategy(
         spdlog::debug("Applying the OuterWallOffset meta-strategy with offset = {}", outer_wall_offset);
         ret = make_unique<OuterWallInsetBeadingStrategy>(outer_wall_offset, std::move(ret));
     }
+    if (inner_wall_offset != 0)
+    {
+        spdlog::debug("Applying the InnerWallOffset meta-strategy with offset = {}", inner_wall_offset);
+        ret = make_unique<InnerWallInsetBeadingStrategy>(inner_wall_offset, std::move(ret));
+    }
 
     // Apply the LimitedBeadingStrategy last, since that adds a 0-width marker wall which other beading strategies shouldn't touch.
     spdlog::debug("Applying the Limited Beading meta-strategy with maximum bead count = {}", max_bead_count);

src/BeadingStrategy/InnerWallInsetBeadingStrategy.cpp

@@ -0,0 +1,73 @@
+// Copyright (c) 2026 UltiMaker
+// CuraEngine is released under the terms of the AGPLv3 or higher.
+
+#include "BeadingStrategy/InnerWallInsetBeadingStrategy.h"
+
+#include <range/v3/view/drop.hpp>
+
+#include <algorithm>
+
+namespace cura
+{
+InnerWallInsetBeadingStrategy::InnerWallInsetBeadingStrategy(coord_t outer_wall_offset, BeadingStrategyPtr parent)
+    : BeadingStrategy(*parent)
+    , parent_(std::move(parent))
+    , inner_wall_offset_(outer_wall_offset)
+{
+    name_ = "InnerWallInsetBeadingStrategy";
+}
+
+
+coord_t InnerWallInsetBeadingStrategy::getOptimalThickness(coord_t bead_count) const
+{
+    return parent_->getOptimalThickness(bead_count);
+}
+
+coord_t InnerWallInsetBeadingStrategy::getTransitionThickness(coord_t lower_bead_count) const
+{
+    return parent_->getTransitionThickness(lower_bead_count);
+}
+
+coord_t InnerWallInsetBeadingStrategy::getOptimalBeadCount(coord_t thickness) const
+{
+    return parent_->getOptimalBeadCount(thickness);
+}
+
+coord_t InnerWallInsetBeadingStrategy::getTransitioningLength(coord_t lower_bead_count) const
+{
+    return parent_->getTransitioningLength(lower_bead_count);
+}
+
+std::string InnerWallInsetBeadingStrategy::toString() const
+{
+    return std::string("InnerWallInsetBeadingStrategy+") + parent_->toString();
+}
+
+BeadingStrategy::Beading InnerWallInsetBeadingStrategy::compute(coord_t thickness, coord_t bead_count) const
+{
+    Beading ret = parent_->compute(thickness, bead_count);
+
+    // Actual count and thickness as represented by extant walls. Don't count any potential zero-width 'signaling' walls.
+    bead_count = std::count_if(
+        ret.bead_widths.begin(),
+        ret.bead_widths.end(),
+        [](const coord_t width)
+        {
+            return width > 0;
+        });
+
+    // No need to apply any inset if there is just a single wall.
+    if (bead_count < 2)
+    {
+        return ret;
+    }
+
+    for (auto& location : ret.toolpath_locations | ranges::views::drop(1))
+    {
+        location += inner_wall_offset_;
+    }
+
+    return ret;
+}
+
+} // namespace cura

src/WallToolPaths.cpp

@@ -27,6 +27,7 @@ WallToolPaths::WallToolPaths(
     const coord_t nominal_bead_width,
     const size_t inset_count,
     const coord_t wall_0_inset,
+    const coord_t wall_x_inset,
     const Settings& settings,
     const int layer_idx,
     SectionType section_type)
@@ -35,6 +36,7 @@ WallToolPaths::WallToolPaths(
     , bead_width_x_(nominal_bead_width)
     , inset_count_(inset_count)
     , wall_0_inset_(wall_0_inset)
+    , wall_x_inset_(wall_x_inset)
     , print_thin_walls_(settings.get<bool>("fill_outline_gaps"))
     , min_feature_size_(nominal_bead_width / 4)
     , min_bead_width_(std::min(min_even_wall_line_width_, min_odd_wall_line_width_))
@@ -61,6 +63,7 @@ WallToolPaths::WallToolPaths(
     const coord_t bead_width_x,
     const size_t inset_count,
     const coord_t wall_0_inset,
+    const coord_t wall_x_inset,
     const Settings& settings,
     const int layer_idx,
     SectionType section_type)
@@ -69,6 +72,7 @@ WallToolPaths::WallToolPaths(
     , bead_width_x_(bead_width_x)
     , inset_count_(inset_count)
     , wall_0_inset_(wall_0_inset)
+    , wall_x_inset_(wall_x_inset)
     , print_thin_walls_(settings.get<bool>("fill_outline_gaps"))
     , min_feature_size_(settings.get<coord_t>("min_feature_size"))
     , min_bead_width_(settings.get<coord_t>("min_bead_width"))
@@ -120,6 +124,7 @@ const std::vector<VariableWidthLines>& WallToolPaths::generate()
         wall_add_middle_threshold,
         max_bead_count,
         wall_0_inset_,
+        wall_x_inset_,
         wall_distribution_count_);
     SkeletalTrapezoidation wall_maker(
         prepared_outline,

src/WallsComputation.cpp

@@ -61,6 +61,7 @@ void WallsComputation::generateWalls(SliceLayerPart* part, SectionType section_t
     const Ratio line_width_0_factor = first_layer ? settings_.get<ExtruderTrain&>("wall_0_extruder_nr").settings_.get<Ratio>("initial_layer_line_width_factor") : 1.0_r;
     const coord_t line_width_0 = settings_.get<coord_t>("wall_line_width_0") * line_width_0_factor;
     const coord_t wall_0_inset = settings_.get<coord_t>("wall_0_inset");
+    const coord_t wall_x_inset = settings_.get<coord_t>("wall_x_inset");
 
     const Ratio line_width_x_factor = first_layer ? settings_.get<ExtruderTrain&>("wall_x_extruder_nr").settings_.get<Ratio>("initial_layer_line_width_factor") : 1.0_r;
     const coord_t line_width_x = settings_.get<coord_t>("wall_line_width_x") * line_width_x_factor;
@@ -81,7 +82,7 @@ void WallsComputation::generateWalls(SliceLayerPart* part, SectionType section_t
     }
     else
     {
-        WallToolPaths wall_tool_paths(part->outline, line_width_0, line_width_x, wall_count, wall_0_inset, settings_, layer_nr_, section_type);
+        WallToolPaths wall_tool_paths(part->outline, line_width_0, line_width_x, wall_count, wall_0_inset, wall_x_inset, settings_, layer_nr_, section_type);
         part->wall_toolpaths = wall_tool_paths.getToolPaths();
         part->inner_area = wall_tool_paths.getInnerContour();
     }

src/infill.cpp

@@ -71,7 +71,8 @@ Shape Infill::generateWallToolPaths(
     if (wall_line_count > 0)
     {
         constexpr coord_t wall_0_inset = 0; // Don't apply any outer wall inset for these. That's just for the outer wall.
-        WallToolPaths wall_toolpaths(outer_contour, line_width, wall_line_count, wall_0_inset, settings, layer_idx, section_type);
+        constexpr coord_t wall_x_inset = 0; // Don't apply any inner wall inset for these. That's just for the outer wall.
+        WallToolPaths wall_toolpaths(outer_contour, line_width, wall_line_count, wall_0_inset, wall_x_inset, settings, layer_idx, section_type);
         wall_toolpaths.pushToolPaths(toolpaths);
         inner_contour = wall_toolpaths.getInnerContour();
     }
@@ -142,7 +143,8 @@ void Infill::generate(
 
         // Fill narrow area with walls.
         const size_t narrow_wall_count = small_area_width_ / infill_line_width_ + 1;
-        WallToolPaths wall_toolpaths(small_infill, infill_line_width_, narrow_wall_count, 0, settings, layer_idx, section_type);
+        const coord_t inset = 0; // outer/inner wall inset is set to 0
+        WallToolPaths wall_toolpaths(small_infill, infill_line_width_, narrow_wall_count, inset, inset, settings, layer_idx, section_type);
         std::vector<VariableWidthLines> small_infill_paths = wall_toolpaths.getToolPaths();
         scripta::log(
             "infill_small_infill_paths_0",
@@ -505,8 +507,9 @@ void Infill::generateConcentricInfill(const Shape& outline, std::vector<Variable
         }
 
         constexpr size_t inset_wall_count = 1; // 1 wall at a time.
-        constexpr coord_t wall_0_inset = 0; // Don't apply any outer wall inset for these. That's just for the outer wall.
-        WallToolPaths wall_toolpaths(current_inset, infill_line_width_, inset_wall_count, wall_0_inset, settings, layer_idx, SectionType::CONCENTRIC_INFILL);
+        constexpr coord_t wall_0_inset = 0; // Don't apply any inner/outer wall inset for these. That's just for the outer wall.
+        constexpr coord_t wall_x_inset = 0; // Don't apply any outer wall inset for these. That's just for the outer wall.
+        WallToolPaths wall_toolpaths(current_inset, infill_line_width_, inset_wall_count, wall_0_inset, wall_x_inset, settings, layer_idx, SectionType::CONCENTRIC_INFILL);
         const std::vector<VariableWidthLines> inset_paths = wall_toolpaths.getToolPaths();
         toolpaths.insert(toolpaths.end(), inset_paths.begin(), inset_paths.end());