Wipe tower sparse layers combination (#15841)

src/libslic3r/GCode/WipeTower.hpp

@@ -152,6 +152,10 @@ public:
         bool               is_contact = false;
         NozzleChangeResult nozzle_change_result;
 
+        // Orca: folded into a later, thicker layer, so the emitter drops it. Set by the tower, so
+        // the two cannot disagree about which layers print.
+        bool               combined_away = false;
+
 		// Sum the total length of the extrusion.
 		float total_extrusion_length_in_plane() {
 			float e_length = 0.f;
@@ -391,6 +395,8 @@ public:
         float filament_tower_interface_pre_extrusion_dist = 0;
         float filament_tower_interface_pre_extrusion_length = 0;
         float filament_petg_pre_extrusion_offset_dist = 0;
+        // Tallest layer this filament's nozzle can lay down; caps the sparse layer combination.
+        float max_layer_height = 0.f;
     };
 
 
@@ -522,6 +528,7 @@ private:
     //float           m_extra_loading_move        = 0.f;
     float           m_bridging                  = 0.f;
     bool            m_sparse_layers_skipped     = false;
+    bool            m_sparse_layers_combined    = false;
     // BBS: remove useless config
     //bool            m_set_extruder_trimpot      = false;
     bool            m_adhesion                  = true;
@@ -595,6 +602,8 @@ private:
     }
 	// Calculates depth for all layers and propagates them downwards
 	void plan_tower();
+	// Whether the layer reaches the G-code, and so whether its extrusions count as filament used.
+	bool layer_is_printed(bool toolchanges_on_layer) const;
 
 	// Goes through m_plan and recalculates depths and width of the WT to make it exactly square - experimental
 	void make_wipe_tower_square();
@@ -634,6 +643,8 @@ private:
 		float depth;	// depth of the layer based on all layers above
 		float extra_spacing;
         bool  extruder_fill{true};
+		// Folded into a later, thicker layer, so this one prints nothing at all.
+		bool  combined_away{false};
 		float toolchanges_depth() const { float sum = 0.f; for (const auto &a : tool_changes) sum += a.required_depth; return sum; }
 
 		std::vector<ToolChange> tool_changes;
@@ -700,6 +711,62 @@ std::vector<float> compute_compacted_wipe_tower_z(const std::vector<std::vector<
                                                   float base_z = 0.f);
 
 
+// Combination rule for wipe_tower_sparse_layers_combination. Nothing is compacted - the tower keeps
+// following the object - but a run of consecutive toolchange-free layers prints as one thicker layer,
+// the way infill combination merges sparse infill. Shared so that neither tower generator nor the
+// G-code emitter can combine on its own.
+
+// Whether sparse layers are really combined. Skipping them outright is the stronger answer to the
+// same problem and wins over this; smooth timelapse and wrapping detection need a tower on every
+// layer, so they rule it out too.
+bool wipe_tower_sparse_layers_combined(const PrintConfig &config);
+
+// A planned layer folded into a later, thicker one prints nothing at all.
+bool wipe_tower_layer_is_combined_away(const std::vector<WipeTower::ToolChangeResult> &layer_tool_changes);
+
+// Folds runs of sparse layers into one. layer_height is raised in place on the layer that prints a
+// run - always its last, so the merged extrusion lands on top of what it covers - and the returned
+// mask marks the layers that now print nothing. A run stops growing once one more layer would pass
+// max_layer_height of the nozzle that prints it. first_layer_idx and below never combine: the
+// tower's first layer carries the brim.
+std::vector<char> combine_sparse_wipe_tower_layers(std::vector<float>       &layer_height,
+                                                   const std::vector<char>  &layer_is_sparse,
+                                                   const std::vector<float> &max_layer_height,
+                                                   size_t                    first_layer_idx);
+
+// Applies the rule above to a planned tower. Either generator's plan fits: both carry height,
+// tool_changes and combined_away per layer, and index their filament parameters by tool.
+template<class PlanLayers, class FilamentParams>
+void combine_sparse_wipe_tower_plan(PlanLayers &plan, const FilamentParams &filpar, size_t first_layer_idx, size_t initial_tool)
+{
+    const size_t       n = plan.size();
+    std::vector<float> heights(n);
+    std::vector<char>  sparse(n);
+    std::vector<float> caps(n);
+
+    // A layer with no toolchange prints with the filament the layer below left loaded.
+    size_t tool = initial_tool;
+    for (const auto &layer : plan)
+        if (! layer.tool_changes.empty()) {
+            tool = layer.tool_changes.front().old_tool;
+            break;
+        }
+    for (size_t i = 0; i < n; ++i) {
+        heights[i] = plan[i].height;
+        sparse[i]  = plan[i].tool_changes.empty() ? 1 : 0;
+        caps[i]    = tool < filpar.size() ? filpar[tool].max_layer_height : 0.f;
+        if (! plan[i].tool_changes.empty())
+            tool = plan[i].tool_changes.back().new_tool;
+    }
+
+    const std::vector<char> combined_away = combine_sparse_wipe_tower_layers(heights, sparse, caps, first_layer_idx);
+    for (size_t i = 0; i < n; ++i) {
+        plan[i].height        = heights[i];
+        plan[i].combined_away = combined_away[i] != 0;
+    }
+}
+
+
 } // namespace Slic3r
 
 #endif // WipeTowerPrusaMM_hpp_