Brick Layers / Staggered Perimeter implementation

doc/Home.md

@@ -36,4 +36,5 @@ The guide below takes you through the key calibration tests in Orca - flow rate,
 - [How to build Orca Slicer](./How-to-build)
 - [Localization and translation guide](Localization_guide)
 - [Developer Reference](https://github.com/SoftFever/OrcaSlicer/blob/main/doc/developer-reference/Home.md)
-- [How to create profiles](./How-to-create-profiles)
+- [How to create profiles](./How-to-create-profiles)
+- [List of staggered perimiters known issues](./staggered-perimiters-known-issues.md)

doc/staggered-perimiters-known-issues.md

@@ -0,0 +1,23 @@
+# Staggered layers is currently in *Alpha*.
+
+![Icon](https://cdn.discordapp.com/attachments/1087393628420329585/1332429863180570735/staggered_layers_icon.png?ex=67953982&is=6793e802&hm=192dffcbf898bed5a9700a7cc6cc879413b1216aad2f0e97845a6d751f2be7be&)
+
+---
+
+## If you find an issue or encounter a bug that is not on this list, please let us know by either:
+#### - Opening an issue on this GitHub repo
+#### - Sending an Email to `[email protected]`
+#### - Sending a Direct Message on Discord to `Divide#4615` or `Xero#1678`
+
+-----
+
+# Known Issues:
+- Staggared layers does not take in to account the slope of a wall, leading to `Inner-wall`s getting staggared even when visible from above ( [img1](https://cdn.discordapp.com/attachments/1314975632236609651/1332410916154773504/image.png?ex=679527dd&is=6793d65d&hm=683e08e6b6629974bc8bc11e14b9d0acd0e23335eafebeb43ede828c2acea57e&) | [img2](https://cdn.discordapp.com/attachments/1314975632236609651/1332410869975486484/image.png?ex=679527d2&is=6793d652&hm=8196be2e6b31e7202fb11f628ae4aa1d9deed9f4daa41bb414cecefff1a6448f&) )
+- When `only_one_wall_first_layer` is **enabled**, the flowrate adjustment to correct for the lifted `Inner-wall`s is not correctly applied ( [img1](https://cdn.discordapp.com/attachments/1314975632236609651/1332410869975486484/image.png?ex=679527d2&is=6793d652&hm=8196be2e6b31e7202fb11f628ae4aa1d9deed9f4daa41bb414cecefff1a6448f&) | [img2](https://cdn.discordapp.com/attachments/1314975632236609651/1332422246735548478/image.png?ex=6795326a&is=6793e0ea&hm=02358016b0ae7c4d39cca76d1d926fe2cb2e3ee659517d519542c3c06a07471f&) )
+- Having multiple models of different heights causes the check for the top layer to only work on the talest model (even if only 1 of the models has the setting enabled
+- Orca slicer layer preview sees 1 layer as multiple different layers (usually 3, (lower walls, raised walls, infill). Sometimes 2, (lower walls and infill, raised walls)) (this is worsened if an object has 2 seperate sections of `outer-walls` as they get treated as seperate 'towers')
+- Perimiters on internal holes are not staggered, only the outer most walls ( [img1](https://cdn.discordapp.com/attachments/1314975632236609651/1333403537425829898/image.png?ex=6798c450&is=679772d0&hm=dc87d94afa168c7ce6bdf75775669932daab1a034929302b3ff5c55c989beb83&) | [img2](https://cdn.discordapp.com/attachments/1314975632236609651/1333403854011629588/image.png?ex=6798c49c&is=6797731c&hm=2aa02f8e42fe59a4e954000a8d0f1912177b92234b947952dbda476a6ce67ca7&) )
+
+# Incompatible settings: 
+- `Adaptive Layer Height` is not currently supported
+- `Initial_layer_print_height` & `Layer_height` must currently be the same

src/libslic3r/ExtrusionEntity.hpp

@@ -160,10 +160,14 @@ class ExtrusionPath : public ExtrusionEntity
     // Height of the extrusion, used for visualization purposes.
     float height;
 
-    ExtrusionPath() : mm3_per_mm(-1), width(-1), height(-1), m_role(erNone), m_no_extrusion(false) {}
-    ExtrusionPath(ExtrusionRole role) : mm3_per_mm(-1), width(-1), height(-1), m_role(role), m_no_extrusion(false) {}
-    ExtrusionPath(ExtrusionRole role, double mm3_per_mm, float width, float height, bool no_extrusion = false) : mm3_per_mm(mm3_per_mm), width(width), height(height), m_role(role), m_no_extrusion(no_extrusion) {}
-    ExtrusionPath(double overhang_degree, int curve_degree, ExtrusionRole role, double mm3_per_mm, float width, float height) : overhang_degree(overhang_degree), curve_degree(curve_degree), mm3_per_mm(mm3_per_mm), width(width), height(height), m_role(role) {}
+    //These properties are just for staggered perimeter production.
+    float z_offset; //z_offset to be multiplied to the layer height, default is 0
+    float extrusion_multiplier; //increase in extrusion, default is 1
+
+    ExtrusionPath() : mm3_per_mm(-1), width(-1), height(-1), m_role(erNone), m_no_extrusion(false), z_offset(0.0), extrusion_multiplier(1.0){}
+    ExtrusionPath(ExtrusionRole role) : mm3_per_mm(-1), width(-1), height(-1), m_role(role), m_no_extrusion(false), z_offset(0.0), extrusion_multiplier(1.0) {}
+    ExtrusionPath(ExtrusionRole role, double mm3_per_mm, float width, float height, bool no_extrusion = false) : mm3_per_mm(mm3_per_mm), width(width), height(height), m_role(role), m_no_extrusion(no_extrusion) , z_offset(0.0), extrusion_multiplier(1.0) {}
+    ExtrusionPath(double overhang_degree, int curve_degree, ExtrusionRole role, double mm3_per_mm, float width, float height) : overhang_degree(overhang_degree), curve_degree(curve_degree), mm3_per_mm(mm3_per_mm), width(width), height(height), m_role(role) , z_offset(0.0), extrusion_multiplier(1.0){}
 
     ExtrusionPath(const ExtrusionPath &rhs)
         : polyline(rhs.polyline)
@@ -175,6 +179,8 @@ class ExtrusionPath : public ExtrusionEntity
         , m_can_reverse(rhs.m_can_reverse)
         , m_role(rhs.m_role)
         , m_no_extrusion(rhs.m_no_extrusion)
+		, z_offset(rhs.z_offset)
+		, extrusion_multiplier(rhs.extrusion_multiplier)
     {}
     ExtrusionPath(ExtrusionPath &&rhs)
         : polyline(std::move(rhs.polyline))
@@ -186,6 +192,8 @@ class ExtrusionPath : public ExtrusionEntity
         , m_can_reverse(rhs.m_can_reverse)
         , m_role(rhs.m_role)
         , m_no_extrusion(rhs.m_no_extrusion)
+		, z_offset(rhs.z_offset)
+		, extrusion_multiplier(rhs.extrusion_multiplier)
     {}
     ExtrusionPath(const Polyline &polyline, const ExtrusionPath &rhs)
         : polyline(polyline)
@@ -197,6 +205,8 @@ class ExtrusionPath : public ExtrusionEntity
         , m_can_reverse(rhs.m_can_reverse)
         , m_role(rhs.m_role)
         , m_no_extrusion(rhs.m_no_extrusion)
+		, z_offset(rhs.z_offset)
+		, extrusion_multiplier(rhs.extrusion_multiplier)
     {}
     ExtrusionPath(Polyline &&polyline, const ExtrusionPath &rhs)
         : polyline(std::move(polyline))
@@ -208,6 +218,8 @@ class ExtrusionPath : public ExtrusionEntity
         , m_can_reverse(rhs.m_can_reverse)
         , m_role(rhs.m_role)
         , m_no_extrusion(rhs.m_no_extrusion)
+		, z_offset(rhs.z_offset)
+		, extrusion_multiplier(rhs.extrusion_multiplier)
     {}
 
     ExtrusionPath& operator=(const ExtrusionPath& rhs) {
@@ -220,6 +232,8 @@ class ExtrusionPath : public ExtrusionEntity
         this->overhang_degree = rhs.overhang_degree;
         this->curve_degree = rhs.curve_degree;
         this->polyline = rhs.polyline;
+        this->z_offset = rhs.z_offset;
+        this->extrusion_multiplier = rhs.extrusion_multiplier;
         return *this;
     }
     ExtrusionPath& operator=(ExtrusionPath&& rhs) {
@@ -232,6 +246,8 @@ class ExtrusionPath : public ExtrusionEntity
         this->overhang_degree = rhs.overhang_degree;
         this->curve_degree = rhs.curve_degree;
         this->polyline = std::move(rhs.polyline);
+        this->z_offset = rhs.z_offset;
+        this->extrusion_multiplier = rhs.extrusion_multiplier;
         return *this;
     }
 

src/libslic3r/GCode.cpp

@@ -5102,7 +5102,8 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
 
     const auto get_sloped_z = [&sloped, this](double z_ratio) {
         const auto height = sloped->height;
-        return lerp(m_nominal_z - height, m_nominal_z, z_ratio);
+        const auto z_offset = sloped->z_offset;
+        return lerp(m_nominal_z + z_offset * height - height, m_nominal_z + z_offset * height, z_ratio);
     };
 
     // go to first point of extrusion path
@@ -5113,7 +5114,7 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
             path.first_point(),
             path.role(),
             "move to first " + description + " point",
-            sloped == nullptr ? DBL_MAX : get_sloped_z(sloped->slope_begin.z_ratio)
+            sloped == nullptr ? m_nominal_z + path.z_offset * path.height : get_sloped_z(sloped->slope_begin.z_ratio)
         );
         m_need_change_layer_lift_z = false;
     }
@@ -5183,7 +5184,7 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
     }
 
     // calculate extrusion length per distance unit
-    auto _mm3_per_mm = path.mm3_per_mm * this->config().print_flow_ratio;
+    auto _mm3_per_mm = path.mm3_per_mm * path.extrusion_multiplier * this->config().print_flow_ratio;
     if (path.role() == erTopSolidInfill)
         _mm3_per_mm *= m_config.top_solid_infill_flow_ratio;
     else if (path.role() == erBottomSurface)

src/libslic3r/LayerRegion.cpp

@@ -99,7 +99,8 @@ void LayerRegion::make_perimeters(const SurfaceCollection &slices, const LayerRe
         &this->thin_fills,
         fill_surfaces,
         //BBS
-        fill_no_overlap
+        fill_no_overlap, 
+        this->layer()->object()->layer_count()
     );
 
     if (this->layer()->lower_layer != nullptr)

src/libslic3r/PerimeterGenerator.cpp

@@ -1291,6 +1291,29 @@ static ExtrusionEntityCollection traverse_extrusions(const PerimeterGenerator& p
             extrusion_paths_append(paths, *extrusion, role, is_external ? perimeter_generator.ext_perimeter_flow : perimeter_generator.perimeter_flow);
         }
 
+        auto check_and_stagger_path = [perimeter_generator](ExtrusionPath& cur_path) { 
+            bool was_staggered = false;
+            if (perimeter_generator.layer_id == 1 && perimeter_generator.number_of_layers >= 4) // i.e. layer after the first one
+            {
+                cur_path.extrusion_multiplier = 1.5;
+                was_staggered                 = true;
+            } else if (perimeter_generator.layer_id == perimeter_generator.number_of_layers - 2 &&
+                       perimeter_generator.number_of_layers >= 4) // i.e. last layer before the last one
+            {
+                cur_path.extrusion_multiplier = 0.5;
+                was_staggered                 = true;
+            }
+
+			if (perimeter_generator.layer_id != perimeter_generator.number_of_layers - 2 &&
+			perimeter_generator.number_of_layers >= 4) // i.e. last layer
+            {
+                cur_path.z_offset = 0.5;
+                was_staggered     = true;
+            }
+
+			return was_staggered;
+		};
+
         // Append paths to collection.
         if (!paths.empty()) {
             if (extrusion->is_closed) {
@@ -1304,6 +1327,14 @@ static ExtrusionEntityCollection traverse_extrusions(const PerimeterGenerator& p
                 }
                 assert(extrusion_loop.paths.front().first_point() == extrusion_loop.paths.back().last_point());
 
+				//This is for staggered layers. 
+				//All odd perimeters are staggerd up by half the layer height                
+                if (extrusion->inset_idx % 2 == 1 && perimeter_generator.config->staggered_perimeters) {
+                    for (size_t path_idx = 0; path_idx < extrusion_loop.paths.size(); path_idx++) {
+                        ExtrusionPath& cur_path = extrusion_loop.paths[path_idx];
+                        check_and_stagger_path(cur_path);
+                    }
+                }
                 extrusion_coll.append(std::move(extrusion_loop));
             }
             else {
@@ -1325,6 +1356,15 @@ static ExtrusionEntityCollection traverse_extrusions(const PerimeterGenerator& p
                     multi_path.paths.emplace_back(std::move(*it_path));
                 }
 
+				//This is for staggered layers. 
+				//All odd perimeters are staggerd up by half the layer height                
+                if (extrusion->inset_idx % 2 == 1 && perimeter_generator.config->staggered_perimeters) {
+                    for (size_t path_idx = 0; path_idx < multi_path.paths.size(); path_idx++) {
+                        ExtrusionPath& cur_path = multi_path.paths[path_idx];
+                        check_and_stagger_path(cur_path);
+                    }
+                }
+
                 extrusion_coll.append(ExtrusionMultiPath(std::move(multi_path)));
             }
         }
@@ -3162,8 +3202,15 @@ void PerimeterGenerator::process_arachne()
             }
         }
 
+        if (this->config->staggered_perimeters) { // If staggered layers are on, all odd perimeters will be staggered and should be printed after the non staggered perimeters
+            std::sort(ordered_extrusions.begin(), ordered_extrusions.end(), 
+                [](PerimeterGeneratorArachneExtrusion extrusion_1, PerimeterGeneratorArachneExtrusion extrusion_2) -> bool {
+                return extrusion_1.extrusion->inset_idx % 2 <= extrusion_2.extrusion->inset_idx % 2;
+                });
+        }
+
        // printf("New Layer: Layer ID %d\n",layer_id); //debug - new layer
-        if (this->config->wall_sequence == WallSequence::InnerOuterInner && layer_id > 0) { // only enable inner outer inner algorithm after first layer
+        if (this->config->wall_sequence == WallSequence::InnerOuterInner && layer_id > 0 && !this->config->staggered_perimeters ) { // only enable inner outer inner algorithm after first layer
             if (ordered_extrusions.size() > 2) { // 3 walls minimum needed to do inner outer inner ordering
                 int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
                 int arr_i, arr_j = 0;    // indexes to run through the walls in the for loops
@@ -3239,7 +3286,7 @@ void PerimeterGenerator::process_arachne()
                     // printf("Layer ID %d, Outer index %d, inner index %d, second inner index %d, maximum internal perimeter %d \n",layer_id,outer,first_internal,second_internal, max_internal);
                     if (outer > -1 && first_internal > -1 && second_internal > -1) { // found all three perimeters to re-order? If not the perimeters will be processed outside in.
                         std::vector<PerimeterGeneratorArachneExtrusion> inner_outer_extrusions; // temporary array to hold extrusions for reordering
-                        inner_outer_extrusions.resize(max_internal - position + 1); // reserve array containing the number of perimeters before a new island. Variables are array indexes hence need to add +1 to convert to position allocations
+                        inner_outer_extrusions.reserve(max_internal - position + 1); // reserve array containing the number of perimeters before a new island. Variables are array indexes hence need to add +1 to convert to position allocations
                         // printf("Allocated array size %d, max_internal index %d, start position index %d \n",max_internal-position+1,max_internal,position);
 
                         for (arr_j = max_internal; arr_j >=position; --arr_j){ // go inside out towards the external perimeter (perimeters in reverse order) and store all internal perimeters until the first one identified with inset index 2

src/libslic3r/PerimeterGenerator.hpp

@@ -66,6 +66,7 @@ class PerimeterGenerator {
     const ExPolygons            *lower_slices;
     double                       layer_height;
     int                          layer_id;
+    size_t                       number_of_layers;
     coordf_t                     slice_z;
     Flow                         perimeter_flow;
     Flow                         ext_perimeter_flow;
@@ -113,15 +114,19 @@ class PerimeterGenerator {
         // Infills without the gap fills
         SurfaceCollection*          fill_surfaces,
         //BBS
-        ExPolygons*                 fill_no_overlap)
+        ExPolygons*                 fill_no_overlap,
+        size_t number_of_layers)
         : slices(slices), compatible_regions(compatible_regions), upper_slices(nullptr), lower_slices(nullptr), layer_height(layer_height),
             slice_z(slice_z), layer_id(-1), perimeter_flow(flow), ext_perimeter_flow(flow),
             overhang_flow(flow), solid_infill_flow(flow),
             config(config), object_config(object_config), print_config(print_config),
             m_spiral_vase(spiral_mode),
             m_scaled_resolution(scaled<double>(print_config->resolution.value > EPSILON ? print_config->resolution.value : EPSILON)),
-            loops(loops), gap_fill(gap_fill), fill_surfaces(fill_surfaces), fill_no_overlap(fill_no_overlap),
-            m_ext_mm3_per_mm(-1), m_mm3_per_mm(-1), m_mm3_per_mm_overhang(-1), m_ext_mm3_per_mm_smaller_width(-1)
+            loops(loops), gap_fill(gap_fill), fill_surfaces(fill_surfaces), fill_no_overlap(fill_no_overlap), m_ext_mm3_per_mm(-1)
+        , m_mm3_per_mm(-1)
+        , m_mm3_per_mm_overhang(-1)
+        , m_ext_mm3_per_mm_smaller_width(-1)
+        , number_of_layers(number_of_layers)
         {}
 
     void        process_classic();

src/libslic3r/Preset.cpp

@@ -783,7 +783,7 @@ bool Preset::has_cali_lines(PresetBundle* preset_bundle)
 static std::vector<std::string> s_Preset_print_options {
     "layer_height", "initial_layer_print_height", "wall_loops", "alternate_extra_wall", "slice_closing_radius", "spiral_mode", "spiral_mode_smooth", "spiral_mode_max_xy_smoothing", "slicing_mode",
     "top_shell_layers", "top_shell_thickness", "bottom_shell_layers", "bottom_shell_thickness",
-    "extra_perimeters_on_overhangs", "ensure_vertical_shell_thickness", "reduce_crossing_wall", "detect_thin_wall", "detect_overhang_wall", "overhang_reverse", "overhang_reverse_threshold","overhang_reverse_internal_only", "wall_direction",
+    "extra_perimeters_on_overhangs", "ensure_vertical_shell_thickness", "reduce_crossing_wall", "detect_thin_wall", "staggered_perimeters", "detect_overhang_wall", "overhang_reverse", "overhang_reverse_threshold","overhang_reverse_internal_only", "wall_direction",
     "seam_position", "staggered_inner_seams", "wall_sequence", "is_infill_first", "sparse_infill_density", "sparse_infill_pattern", "lattice_angle_1", "lattice_angle_2", "top_surface_pattern", "bottom_surface_pattern",
     "infill_direction", "solid_infill_direction", "rotate_solid_infill_direction",  "counterbore_hole_bridging",
     "minimum_sparse_infill_area", "reduce_infill_retraction","internal_solid_infill_pattern","gap_fill_target",

src/libslic3r/PrintConfig.cpp

@@ -5123,6 +5123,13 @@ void PrintConfigDef::init_fff_params()
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionBool(false));
 
+    def          = this->add("staggered_perimeters", coBool);
+    def->label   = L("Stagger perimeters");
+    def->category = L("Strength");
+    def->tooltip = L("This is an experminetal feature that allows you to print staggered perimeters for better layer adhesion and strength.");
+    def->mode    = comAdvanced;
+    def->set_default_value(new ConfigOptionBool(false));
+
     def = this->add("change_filament_gcode", coString);
     def->label = L("Change filament G-code");
     def->tooltip = L("This gcode is inserted when change filament, including T command to trigger tool change");

src/libslic3r/PrintConfig.hpp

@@ -974,6 +974,8 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionFloat, internal_solid_infill_speed))
     // Detect thin walls.
     ((ConfigOptionBool, detect_thin_wall))
+    //staggered layer checking
+    ((ConfigOptionBool,               staggered_perimeters))
     ((ConfigOptionFloatOrPercent, top_surface_line_width))
     ((ConfigOptionInt, top_shell_layers))
     ((ConfigOptionFloat, top_shell_thickness))